/*jshint node:true */
|
/*
|
|
The MIT License (MIT)
|
|
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
|
|
Permission is hereby granted, free of charge, to any person
|
obtaining a copy of this software and associated documentation files
|
(the "Software"), to deal in the Software without restriction,
|
including without limitation the rights to use, copy, modify, merge,
|
publish, distribute, sublicense, and/or sell copies of the Software,
|
and to permit persons to whom the Software is furnished to do so,
|
subject to the following conditions:
|
|
The above copyright notice and this permission notice shall be
|
included in all copies or substantial portions of the Software.
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
SOFTWARE.
|
*/
|
|
'use strict';
|
|
var Output = require('../core/output').Output;
|
var Token = require('../core/token').Token;
|
var acorn = require('./acorn');
|
var Options = require('./options').Options;
|
var Tokenizer = require('./tokenizer').Tokenizer;
|
var line_starters = require('./tokenizer').line_starters;
|
var positionable_operators = require('./tokenizer').positionable_operators;
|
var TOKEN = require('./tokenizer').TOKEN;
|
|
|
function in_array(what, arr) {
|
return arr.indexOf(what) !== -1;
|
}
|
|
function ltrim(s) {
|
return s.replace(/^\s+/g, '');
|
}
|
|
function generateMapFromStrings(list) {
|
var result = {};
|
for (var x = 0; x < list.length; x++) {
|
// make the mapped names underscored instead of dash
|
result[list[x].replace(/-/g, '_')] = list[x];
|
}
|
return result;
|
}
|
|
function reserved_word(token, word) {
|
return token && token.type === TOKEN.RESERVED && token.text === word;
|
}
|
|
function reserved_array(token, words) {
|
return token && token.type === TOKEN.RESERVED && in_array(token.text, words);
|
}
|
// Unsure of what they mean, but they work. Worth cleaning up in future.
|
var special_words = ['case', 'return', 'do', 'if', 'throw', 'else', 'await', 'break', 'continue', 'async'];
|
|
var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline'];
|
|
// Generate map from array
|
var OPERATOR_POSITION = generateMapFromStrings(validPositionValues);
|
|
var OPERATOR_POSITION_BEFORE_OR_PRESERVE = [OPERATOR_POSITION.before_newline, OPERATOR_POSITION.preserve_newline];
|
|
var MODE = {
|
BlockStatement: 'BlockStatement', // 'BLOCK'
|
Statement: 'Statement', // 'STATEMENT'
|
ObjectLiteral: 'ObjectLiteral', // 'OBJECT',
|
ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]',
|
ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)',
|
Conditional: 'Conditional', //'(COND-EXPRESSION)',
|
Expression: 'Expression' //'(EXPRESSION)'
|
};
|
|
function remove_redundant_indentation(output, frame) {
|
// This implementation is effective but has some issues:
|
// - can cause line wrap to happen too soon due to indent removal
|
// after wrap points are calculated
|
// These issues are minor compared to ugly indentation.
|
|
if (frame.multiline_frame ||
|
frame.mode === MODE.ForInitializer ||
|
frame.mode === MODE.Conditional) {
|
return;
|
}
|
|
// remove one indent from each line inside this section
|
output.remove_indent(frame.start_line_index);
|
}
|
|
// we could use just string.split, but
|
// IE doesn't like returning empty strings
|
function split_linebreaks(s) {
|
//return s.split(/\x0d\x0a|\x0a/);
|
|
s = s.replace(acorn.allLineBreaks, '\n');
|
var out = [],
|
idx = s.indexOf("\n");
|
while (idx !== -1) {
|
out.push(s.substring(0, idx));
|
s = s.substring(idx + 1);
|
idx = s.indexOf("\n");
|
}
|
if (s.length) {
|
out.push(s);
|
}
|
return out;
|
}
|
|
function is_array(mode) {
|
return mode === MODE.ArrayLiteral;
|
}
|
|
function is_expression(mode) {
|
return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]);
|
}
|
|
function all_lines_start_with(lines, c) {
|
for (var i = 0; i < lines.length; i++) {
|
var line = lines[i].trim();
|
if (line.charAt(0) !== c) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
function each_line_matches_indent(lines, indent) {
|
var i = 0,
|
len = lines.length,
|
line;
|
for (; i < len; i++) {
|
line = lines[i];
|
// allow empty lines to pass through
|
if (line && line.indexOf(indent) !== 0) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
|
function Beautifier(source_text, options) {
|
options = options || {};
|
this._source_text = source_text || '';
|
|
this._output = null;
|
this._tokens = null;
|
this._last_last_text = null;
|
this._flags = null;
|
this._previous_flags = null;
|
|
this._flag_store = null;
|
this._options = new Options(options);
|
}
|
|
Beautifier.prototype.create_flags = function(flags_base, mode) {
|
var next_indent_level = 0;
|
if (flags_base) {
|
next_indent_level = flags_base.indentation_level;
|
if (!this._output.just_added_newline() &&
|
flags_base.line_indent_level > next_indent_level) {
|
next_indent_level = flags_base.line_indent_level;
|
}
|
}
|
|
var next_flags = {
|
mode: mode,
|
parent: flags_base,
|
last_token: flags_base ? flags_base.last_token : new Token(TOKEN.START_BLOCK, ''), // last token text
|
last_word: flags_base ? flags_base.last_word : '', // last TOKEN.WORD passed
|
declaration_statement: false,
|
declaration_assignment: false,
|
multiline_frame: false,
|
inline_frame: false,
|
if_block: false,
|
else_block: false,
|
do_block: false,
|
do_while: false,
|
import_block: false,
|
in_case_statement: false, // switch(..){ INSIDE HERE }
|
in_case: false, // we're on the exact line with "case 0:"
|
case_body: false, // the indented case-action block
|
case_block: false, // the indented case-action block is wrapped with {}
|
indentation_level: next_indent_level,
|
alignment: 0,
|
line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level,
|
start_line_index: this._output.get_line_number(),
|
ternary_depth: 0
|
};
|
return next_flags;
|
};
|
|
Beautifier.prototype._reset = function(source_text) {
|
var baseIndentString = source_text.match(/^[\t ]*/)[0];
|
|
this._last_last_text = ''; // pre-last token text
|
this._output = new Output(this._options, baseIndentString);
|
|
// If testing the ignore directive, start with output disable set to true
|
this._output.raw = this._options.test_output_raw;
|
|
|
// Stack of parsing/formatting states, including MODE.
|
// We tokenize, parse, and output in an almost purely a forward-only stream of token input
|
// and formatted output. This makes the beautifier less accurate than full parsers
|
// but also far more tolerant of syntax errors.
|
//
|
// For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type
|
// MODE.BlockStatement on the the stack, even though it could be object literal. If we later
|
// encounter a ":", we'll switch to to MODE.ObjectLiteral. If we then see a ";",
|
// most full parsers would die, but the beautifier gracefully falls back to
|
// MODE.BlockStatement and continues on.
|
this._flag_store = [];
|
this.set_mode(MODE.BlockStatement);
|
var tokenizer = new Tokenizer(source_text, this._options);
|
this._tokens = tokenizer.tokenize();
|
return source_text;
|
};
|
|
Beautifier.prototype.beautify = function() {
|
// if disabled, return the input unchanged.
|
if (this._options.disabled) {
|
return this._source_text;
|
}
|
|
var sweet_code;
|
var source_text = this._reset(this._source_text);
|
|
var eol = this._options.eol;
|
if (this._options.eol === 'auto') {
|
eol = '\n';
|
if (source_text && acorn.lineBreak.test(source_text || '')) {
|
eol = source_text.match(acorn.lineBreak)[0];
|
}
|
}
|
|
var current_token = this._tokens.next();
|
while (current_token) {
|
this.handle_token(current_token);
|
|
this._last_last_text = this._flags.last_token.text;
|
this._flags.last_token = current_token;
|
|
current_token = this._tokens.next();
|
}
|
|
sweet_code = this._output.get_code(eol);
|
|
return sweet_code;
|
};
|
|
Beautifier.prototype.handle_token = function(current_token, preserve_statement_flags) {
|
if (current_token.type === TOKEN.START_EXPR) {
|
this.handle_start_expr(current_token);
|
} else if (current_token.type === TOKEN.END_EXPR) {
|
this.handle_end_expr(current_token);
|
} else if (current_token.type === TOKEN.START_BLOCK) {
|
this.handle_start_block(current_token);
|
} else if (current_token.type === TOKEN.END_BLOCK) {
|
this.handle_end_block(current_token);
|
} else if (current_token.type === TOKEN.WORD) {
|
this.handle_word(current_token);
|
} else if (current_token.type === TOKEN.RESERVED) {
|
this.handle_word(current_token);
|
} else if (current_token.type === TOKEN.SEMICOLON) {
|
this.handle_semicolon(current_token);
|
} else if (current_token.type === TOKEN.STRING) {
|
this.handle_string(current_token);
|
} else if (current_token.type === TOKEN.EQUALS) {
|
this.handle_equals(current_token);
|
} else if (current_token.type === TOKEN.OPERATOR) {
|
this.handle_operator(current_token);
|
} else if (current_token.type === TOKEN.COMMA) {
|
this.handle_comma(current_token);
|
} else if (current_token.type === TOKEN.BLOCK_COMMENT) {
|
this.handle_block_comment(current_token, preserve_statement_flags);
|
} else if (current_token.type === TOKEN.COMMENT) {
|
this.handle_comment(current_token, preserve_statement_flags);
|
} else if (current_token.type === TOKEN.DOT) {
|
this.handle_dot(current_token);
|
} else if (current_token.type === TOKEN.EOF) {
|
this.handle_eof(current_token);
|
} else if (current_token.type === TOKEN.UNKNOWN) {
|
this.handle_unknown(current_token, preserve_statement_flags);
|
} else {
|
this.handle_unknown(current_token, preserve_statement_flags);
|
}
|
};
|
|
Beautifier.prototype.handle_whitespace_and_comments = function(current_token, preserve_statement_flags) {
|
var newlines = current_token.newlines;
|
var keep_whitespace = this._options.keep_array_indentation && is_array(this._flags.mode);
|
|
if (current_token.comments_before) {
|
var comment_token = current_token.comments_before.next();
|
while (comment_token) {
|
// The cleanest handling of inline comments is to treat them as though they aren't there.
|
// Just continue formatting and the behavior should be logical.
|
// Also ignore unknown tokens. Again, this should result in better behavior.
|
this.handle_whitespace_and_comments(comment_token, preserve_statement_flags);
|
this.handle_token(comment_token, preserve_statement_flags);
|
comment_token = current_token.comments_before.next();
|
}
|
}
|
|
if (keep_whitespace) {
|
for (var i = 0; i < newlines; i += 1) {
|
this.print_newline(i > 0, preserve_statement_flags);
|
}
|
} else {
|
if (this._options.max_preserve_newlines && newlines > this._options.max_preserve_newlines) {
|
newlines = this._options.max_preserve_newlines;
|
}
|
|
if (this._options.preserve_newlines) {
|
if (newlines > 1) {
|
this.print_newline(false, preserve_statement_flags);
|
for (var j = 1; j < newlines; j += 1) {
|
this.print_newline(true, preserve_statement_flags);
|
}
|
}
|
}
|
}
|
|
};
|
|
var newline_restricted_tokens = ['async', 'break', 'continue', 'return', 'throw', 'yield'];
|
|
Beautifier.prototype.allow_wrap_or_preserved_newline = function(current_token, force_linewrap) {
|
force_linewrap = (force_linewrap === undefined) ? false : force_linewrap;
|
|
// Never wrap the first token on a line
|
if (this._output.just_added_newline()) {
|
return;
|
}
|
|
var shouldPreserveOrForce = (this._options.preserve_newlines && current_token.newlines) || force_linewrap;
|
var operatorLogicApplies = in_array(this._flags.last_token.text, positionable_operators) ||
|
in_array(current_token.text, positionable_operators);
|
|
if (operatorLogicApplies) {
|
var shouldPrintOperatorNewline = (
|
in_array(this._flags.last_token.text, positionable_operators) &&
|
in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)
|
) ||
|
in_array(current_token.text, positionable_operators);
|
shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline;
|
}
|
|
if (shouldPreserveOrForce) {
|
this.print_newline(false, true);
|
} else if (this._options.wrap_line_length) {
|
if (reserved_array(this._flags.last_token, newline_restricted_tokens)) {
|
// These tokens should never have a newline inserted
|
// between them and the following expression.
|
return;
|
}
|
this._output.set_wrap_point();
|
}
|
};
|
|
Beautifier.prototype.print_newline = function(force_newline, preserve_statement_flags) {
|
if (!preserve_statement_flags) {
|
if (this._flags.last_token.text !== ';' && this._flags.last_token.text !== ',' && this._flags.last_token.text !== '=' && (this._flags.last_token.type !== TOKEN.OPERATOR || this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) {
|
var next_token = this._tokens.peek();
|
while (this._flags.mode === MODE.Statement &&
|
!(this._flags.if_block && reserved_word(next_token, 'else')) &&
|
!this._flags.do_block) {
|
this.restore_mode();
|
}
|
}
|
}
|
|
if (this._output.add_new_line(force_newline)) {
|
this._flags.multiline_frame = true;
|
}
|
};
|
|
Beautifier.prototype.print_token_line_indentation = function(current_token) {
|
if (this._output.just_added_newline()) {
|
if (this._options.keep_array_indentation &&
|
current_token.newlines &&
|
(current_token.text === '[' || is_array(this._flags.mode))) {
|
this._output.current_line.set_indent(-1);
|
this._output.current_line.push(current_token.whitespace_before);
|
this._output.space_before_token = false;
|
} else if (this._output.set_indent(this._flags.indentation_level, this._flags.alignment)) {
|
this._flags.line_indent_level = this._flags.indentation_level;
|
}
|
}
|
};
|
|
Beautifier.prototype.print_token = function(current_token) {
|
if (this._output.raw) {
|
this._output.add_raw_token(current_token);
|
return;
|
}
|
|
if (this._options.comma_first && current_token.previous && current_token.previous.type === TOKEN.COMMA &&
|
this._output.just_added_newline()) {
|
if (this._output.previous_line.last() === ',') {
|
var popped = this._output.previous_line.pop();
|
// if the comma was already at the start of the line,
|
// pull back onto that line and reprint the indentation
|
if (this._output.previous_line.is_empty()) {
|
this._output.previous_line.push(popped);
|
this._output.trim(true);
|
this._output.current_line.pop();
|
this._output.trim();
|
}
|
|
// add the comma in front of the next token
|
this.print_token_line_indentation(current_token);
|
this._output.add_token(',');
|
this._output.space_before_token = true;
|
}
|
}
|
|
this.print_token_line_indentation(current_token);
|
this._output.non_breaking_space = true;
|
this._output.add_token(current_token.text);
|
if (this._output.previous_token_wrapped) {
|
this._flags.multiline_frame = true;
|
}
|
};
|
|
Beautifier.prototype.indent = function() {
|
this._flags.indentation_level += 1;
|
this._output.set_indent(this._flags.indentation_level, this._flags.alignment);
|
};
|
|
Beautifier.prototype.deindent = function() {
|
if (this._flags.indentation_level > 0 &&
|
((!this._flags.parent) || this._flags.indentation_level > this._flags.parent.indentation_level)) {
|
this._flags.indentation_level -= 1;
|
this._output.set_indent(this._flags.indentation_level, this._flags.alignment);
|
}
|
};
|
|
Beautifier.prototype.set_mode = function(mode) {
|
if (this._flags) {
|
this._flag_store.push(this._flags);
|
this._previous_flags = this._flags;
|
} else {
|
this._previous_flags = this.create_flags(null, mode);
|
}
|
|
this._flags = this.create_flags(this._previous_flags, mode);
|
this._output.set_indent(this._flags.indentation_level, this._flags.alignment);
|
};
|
|
|
Beautifier.prototype.restore_mode = function() {
|
if (this._flag_store.length > 0) {
|
this._previous_flags = this._flags;
|
this._flags = this._flag_store.pop();
|
if (this._previous_flags.mode === MODE.Statement) {
|
remove_redundant_indentation(this._output, this._previous_flags);
|
}
|
this._output.set_indent(this._flags.indentation_level, this._flags.alignment);
|
}
|
};
|
|
Beautifier.prototype.start_of_object_property = function() {
|
return this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement && (
|
(this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || (reserved_array(this._flags.last_token, ['get', 'set'])));
|
};
|
|
Beautifier.prototype.start_of_statement = function(current_token) {
|
var start = false;
|
start = start || reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD;
|
start = start || reserved_word(this._flags.last_token, 'do');
|
start = start || (!(this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement)) && reserved_array(this._flags.last_token, newline_restricted_tokens) && !current_token.newlines;
|
start = start || reserved_word(this._flags.last_token, 'else') &&
|
!(reserved_word(current_token, 'if') && !current_token.comments_before);
|
start = start || (this._flags.last_token.type === TOKEN.END_EXPR && (this._previous_flags.mode === MODE.ForInitializer || this._previous_flags.mode === MODE.Conditional));
|
start = start || (this._flags.last_token.type === TOKEN.WORD && this._flags.mode === MODE.BlockStatement &&
|
!this._flags.in_case &&
|
!(current_token.text === '--' || current_token.text === '++') &&
|
this._last_last_text !== 'function' &&
|
current_token.type !== TOKEN.WORD && current_token.type !== TOKEN.RESERVED);
|
start = start || (this._flags.mode === MODE.ObjectLiteral && (
|
(this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) || reserved_array(this._flags.last_token, ['get', 'set'])));
|
|
if (start) {
|
this.set_mode(MODE.Statement);
|
this.indent();
|
|
this.handle_whitespace_and_comments(current_token, true);
|
|
// Issue #276:
|
// If starting a new statement with [if, for, while, do], push to a new line.
|
// if (a) if (b) if(c) d(); else e(); else f();
|
if (!this.start_of_object_property()) {
|
this.allow_wrap_or_preserved_newline(current_token,
|
reserved_array(current_token, ['do', 'for', 'if', 'while']));
|
}
|
return true;
|
}
|
return false;
|
};
|
|
Beautifier.prototype.handle_start_expr = function(current_token) {
|
// The conditional starts the statement if appropriate.
|
if (!this.start_of_statement(current_token)) {
|
this.handle_whitespace_and_comments(current_token);
|
}
|
|
var next_mode = MODE.Expression;
|
if (current_token.text === '[') {
|
|
if (this._flags.last_token.type === TOKEN.WORD || this._flags.last_token.text === ')') {
|
// this is array index specifier, break immediately
|
// a[x], fn()[x]
|
if (reserved_array(this._flags.last_token, line_starters)) {
|
this._output.space_before_token = true;
|
}
|
this.print_token(current_token);
|
this.set_mode(next_mode);
|
this.indent();
|
if (this._options.space_in_paren) {
|
this._output.space_before_token = true;
|
}
|
return;
|
}
|
|
next_mode = MODE.ArrayLiteral;
|
if (is_array(this._flags.mode)) {
|
if (this._flags.last_token.text === '[' ||
|
(this._flags.last_token.text === ',' && (this._last_last_text === ']' || this._last_last_text === '}'))) {
|
// ], [ goes to new line
|
// }, [ goes to new line
|
if (!this._options.keep_array_indentation) {
|
this.print_newline();
|
}
|
}
|
}
|
|
if (!in_array(this._flags.last_token.type, [TOKEN.START_EXPR, TOKEN.END_EXPR, TOKEN.WORD, TOKEN.OPERATOR, TOKEN.DOT])) {
|
this._output.space_before_token = true;
|
}
|
} else {
|
if (this._flags.last_token.type === TOKEN.RESERVED) {
|
if (this._flags.last_token.text === 'for') {
|
this._output.space_before_token = this._options.space_before_conditional;
|
next_mode = MODE.ForInitializer;
|
} else if (in_array(this._flags.last_token.text, ['if', 'while', 'switch'])) {
|
this._output.space_before_token = this._options.space_before_conditional;
|
next_mode = MODE.Conditional;
|
} else if (in_array(this._flags.last_word, ['await', 'async'])) {
|
// Should be a space between await and an IIFE, or async and an arrow function
|
this._output.space_before_token = true;
|
} else if (this._flags.last_token.text === 'import' && current_token.whitespace_before === '') {
|
this._output.space_before_token = false;
|
} else if (in_array(this._flags.last_token.text, line_starters) || this._flags.last_token.text === 'catch') {
|
this._output.space_before_token = true;
|
}
|
} else if (this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) {
|
// Support of this kind of newline preservation.
|
// a = (b &&
|
// (c || d));
|
if (!this.start_of_object_property()) {
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
} else if (this._flags.last_token.type === TOKEN.WORD) {
|
this._output.space_before_token = false;
|
|
// function name() vs function name ()
|
// function* name() vs function* name ()
|
// async name() vs async name ()
|
// In ES6, you can also define the method properties of an object
|
// var obj = {a: function() {}}
|
// It can be abbreviated
|
// var obj = {a() {}}
|
// var obj = { a() {}} vs var obj = { a () {}}
|
// var obj = { * a() {}} vs var obj = { * a () {}}
|
var peek_back_two = this._tokens.peek(-3);
|
if (this._options.space_after_named_function && peek_back_two) {
|
// peek starts at next character so -1 is current token
|
var peek_back_three = this._tokens.peek(-4);
|
if (reserved_array(peek_back_two, ['async', 'function']) ||
|
(peek_back_two.text === '*' && reserved_array(peek_back_three, ['async', 'function']))) {
|
this._output.space_before_token = true;
|
} else if (this._flags.mode === MODE.ObjectLiteral) {
|
if ((peek_back_two.text === '{' || peek_back_two.text === ',') ||
|
(peek_back_two.text === '*' && (peek_back_three.text === '{' || peek_back_three.text === ','))) {
|
this._output.space_before_token = true;
|
}
|
}
|
}
|
} else {
|
// Support preserving wrapped arrow function expressions
|
// a.b('c',
|
// () => d.e
|
// )
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
|
// function() vs function ()
|
// yield*() vs yield* ()
|
// function*() vs function* ()
|
if ((this._flags.last_token.type === TOKEN.RESERVED && (this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) ||
|
(this._flags.last_token.text === '*' &&
|
(in_array(this._last_last_text, ['function', 'yield']) ||
|
(this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) {
|
this._output.space_before_token = this._options.space_after_anon_function;
|
}
|
}
|
|
if (this._flags.last_token.text === ';' || this._flags.last_token.type === TOKEN.START_BLOCK) {
|
this.print_newline();
|
} else if (this._flags.last_token.type === TOKEN.END_EXPR || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.END_BLOCK || this._flags.last_token.text === '.' || this._flags.last_token.type === TOKEN.COMMA) {
|
// do nothing on (( and )( and ][ and ]( and .(
|
// TODO: Consider whether forcing this is required. Review failing tests when removed.
|
this.allow_wrap_or_preserved_newline(current_token, current_token.newlines);
|
}
|
|
this.print_token(current_token);
|
this.set_mode(next_mode);
|
if (this._options.space_in_paren) {
|
this._output.space_before_token = true;
|
}
|
|
// In all cases, if we newline while inside an expression it should be indented.
|
this.indent();
|
};
|
|
Beautifier.prototype.handle_end_expr = function(current_token) {
|
// statements inside expressions are not valid syntax, but...
|
// statements must all be closed when their container closes
|
while (this._flags.mode === MODE.Statement) {
|
this.restore_mode();
|
}
|
|
this.handle_whitespace_and_comments(current_token);
|
|
if (this._flags.multiline_frame) {
|
this.allow_wrap_or_preserved_newline(current_token,
|
current_token.text === ']' && is_array(this._flags.mode) && !this._options.keep_array_indentation);
|
}
|
|
if (this._options.space_in_paren) {
|
if (this._flags.last_token.type === TOKEN.START_EXPR && !this._options.space_in_empty_paren) {
|
// () [] no inner space in empty parens like these, ever, ref #320
|
this._output.trim();
|
this._output.space_before_token = false;
|
} else {
|
this._output.space_before_token = true;
|
}
|
}
|
this.deindent();
|
this.print_token(current_token);
|
this.restore_mode();
|
|
remove_redundant_indentation(this._output, this._previous_flags);
|
|
// do {} while () // no statement required after
|
if (this._flags.do_while && this._previous_flags.mode === MODE.Conditional) {
|
this._previous_flags.mode = MODE.Expression;
|
this._flags.do_block = false;
|
this._flags.do_while = false;
|
|
}
|
};
|
|
Beautifier.prototype.handle_start_block = function(current_token) {
|
this.handle_whitespace_and_comments(current_token);
|
|
// Check if this is should be treated as a ObjectLiteral
|
var next_token = this._tokens.peek();
|
var second_token = this._tokens.peek(1);
|
if (this._flags.last_word === 'switch' && this._flags.last_token.type === TOKEN.END_EXPR) {
|
this.set_mode(MODE.BlockStatement);
|
this._flags.in_case_statement = true;
|
} else if (this._flags.case_body) {
|
this.set_mode(MODE.BlockStatement);
|
} else if (second_token && (
|
(in_array(second_token.text, [':', ',']) && in_array(next_token.type, [TOKEN.STRING, TOKEN.WORD, TOKEN.RESERVED])) ||
|
(in_array(next_token.text, ['get', 'set', '...']) && in_array(second_token.type, [TOKEN.WORD, TOKEN.RESERVED]))
|
)) {
|
// We don't support TypeScript,but we didn't break it for a very long time.
|
// We'll try to keep not breaking it.
|
if (in_array(this._last_last_text, ['class', 'interface']) && !in_array(second_token.text, [':', ','])) {
|
this.set_mode(MODE.BlockStatement);
|
} else {
|
this.set_mode(MODE.ObjectLiteral);
|
}
|
} else if (this._flags.last_token.type === TOKEN.OPERATOR && this._flags.last_token.text === '=>') {
|
// arrow function: (param1, paramN) => { statements }
|
this.set_mode(MODE.BlockStatement);
|
} else if (in_array(this._flags.last_token.type, [TOKEN.EQUALS, TOKEN.START_EXPR, TOKEN.COMMA, TOKEN.OPERATOR]) ||
|
reserved_array(this._flags.last_token, ['return', 'throw', 'import', 'default'])
|
) {
|
// Detecting shorthand function syntax is difficult by scanning forward,
|
// so check the surrounding context.
|
// If the block is being returned, imported, export default, passed as arg,
|
// assigned with = or assigned in a nested object, treat as an ObjectLiteral.
|
this.set_mode(MODE.ObjectLiteral);
|
} else {
|
this.set_mode(MODE.BlockStatement);
|
}
|
|
var empty_braces = !next_token.comments_before && next_token.text === '}';
|
var empty_anonymous_function = empty_braces && this._flags.last_word === 'function' &&
|
this._flags.last_token.type === TOKEN.END_EXPR;
|
|
if (this._options.brace_preserve_inline) // check for inline, set inline_frame if so
|
{
|
// search forward for a newline wanted inside this block
|
var index = 0;
|
var check_token = null;
|
this._flags.inline_frame = true;
|
do {
|
index += 1;
|
check_token = this._tokens.peek(index - 1);
|
if (check_token.newlines) {
|
this._flags.inline_frame = false;
|
break;
|
}
|
} while (check_token.type !== TOKEN.EOF &&
|
!(check_token.type === TOKEN.END_BLOCK && check_token.opened === current_token));
|
}
|
|
if ((this._options.brace_style === "expand" ||
|
(this._options.brace_style === "none" && current_token.newlines)) &&
|
!this._flags.inline_frame) {
|
if (this._flags.last_token.type !== TOKEN.OPERATOR &&
|
(empty_anonymous_function ||
|
this._flags.last_token.type === TOKEN.EQUALS ||
|
(reserved_array(this._flags.last_token, special_words) && this._flags.last_token.text !== 'else'))) {
|
this._output.space_before_token = true;
|
} else {
|
this.print_newline(false, true);
|
}
|
} else { // collapse || inline_frame
|
if (is_array(this._previous_flags.mode) && (this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.COMMA)) {
|
if (this._flags.last_token.type === TOKEN.COMMA || this._options.space_in_paren) {
|
this._output.space_before_token = true;
|
}
|
|
if (this._flags.last_token.type === TOKEN.COMMA || (this._flags.last_token.type === TOKEN.START_EXPR && this._flags.inline_frame)) {
|
this.allow_wrap_or_preserved_newline(current_token);
|
this._previous_flags.multiline_frame = this._previous_flags.multiline_frame || this._flags.multiline_frame;
|
this._flags.multiline_frame = false;
|
}
|
}
|
if (this._flags.last_token.type !== TOKEN.OPERATOR && this._flags.last_token.type !== TOKEN.START_EXPR) {
|
if (this._flags.last_token.type === TOKEN.START_BLOCK && !this._flags.inline_frame) {
|
this.print_newline();
|
} else {
|
this._output.space_before_token = true;
|
}
|
}
|
}
|
this.print_token(current_token);
|
this.indent();
|
|
// Except for specific cases, open braces are followed by a new line.
|
if (!empty_braces && !(this._options.brace_preserve_inline && this._flags.inline_frame)) {
|
this.print_newline();
|
}
|
};
|
|
Beautifier.prototype.handle_end_block = function(current_token) {
|
// statements must all be closed when their container closes
|
this.handle_whitespace_and_comments(current_token);
|
|
while (this._flags.mode === MODE.Statement) {
|
this.restore_mode();
|
}
|
|
var empty_braces = this._flags.last_token.type === TOKEN.START_BLOCK;
|
|
if (this._flags.inline_frame && !empty_braces) { // try inline_frame (only set if this._options.braces-preserve-inline) first
|
this._output.space_before_token = true;
|
} else if (this._options.brace_style === "expand") {
|
if (!empty_braces) {
|
this.print_newline();
|
}
|
} else {
|
// skip {}
|
if (!empty_braces) {
|
if (is_array(this._flags.mode) && this._options.keep_array_indentation) {
|
// we REALLY need a newline here, but newliner would skip that
|
this._options.keep_array_indentation = false;
|
this.print_newline();
|
this._options.keep_array_indentation = true;
|
|
} else {
|
this.print_newline();
|
}
|
}
|
}
|
this.restore_mode();
|
this.print_token(current_token);
|
};
|
|
Beautifier.prototype.handle_word = function(current_token) {
|
if (current_token.type === TOKEN.RESERVED) {
|
if (in_array(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) {
|
current_token.type = TOKEN.WORD;
|
} else if (current_token.text === 'import' && in_array(this._tokens.peek().text, ['(', '.'])) {
|
current_token.type = TOKEN.WORD;
|
} else if (in_array(current_token.text, ['as', 'from']) && !this._flags.import_block) {
|
current_token.type = TOKEN.WORD;
|
} else if (this._flags.mode === MODE.ObjectLiteral) {
|
var next_token = this._tokens.peek();
|
if (next_token.text === ':') {
|
current_token.type = TOKEN.WORD;
|
}
|
}
|
}
|
|
if (this.start_of_statement(current_token)) {
|
// The conditional starts the statement if appropriate.
|
if (reserved_array(this._flags.last_token, ['var', 'let', 'const']) && current_token.type === TOKEN.WORD) {
|
this._flags.declaration_statement = true;
|
}
|
} else if (current_token.newlines && !is_expression(this._flags.mode) &&
|
(this._flags.last_token.type !== TOKEN.OPERATOR || (this._flags.last_token.text === '--' || this._flags.last_token.text === '++')) &&
|
this._flags.last_token.type !== TOKEN.EQUALS &&
|
(this._options.preserve_newlines || !reserved_array(this._flags.last_token, ['var', 'let', 'const', 'set', 'get']))) {
|
this.handle_whitespace_and_comments(current_token);
|
this.print_newline();
|
} else {
|
this.handle_whitespace_and_comments(current_token);
|
}
|
|
if (this._flags.do_block && !this._flags.do_while) {
|
if (reserved_word(current_token, 'while')) {
|
// do {} ## while ()
|
this._output.space_before_token = true;
|
this.print_token(current_token);
|
this._output.space_before_token = true;
|
this._flags.do_while = true;
|
return;
|
} else {
|
// do {} should always have while as the next word.
|
// if we don't see the expected while, recover
|
this.print_newline();
|
this._flags.do_block = false;
|
}
|
}
|
|
// if may be followed by else, or not
|
// Bare/inline ifs are tricky
|
// Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e();
|
if (this._flags.if_block) {
|
if (!this._flags.else_block && reserved_word(current_token, 'else')) {
|
this._flags.else_block = true;
|
} else {
|
while (this._flags.mode === MODE.Statement) {
|
this.restore_mode();
|
}
|
this._flags.if_block = false;
|
this._flags.else_block = false;
|
}
|
}
|
|
if (this._flags.in_case_statement && reserved_array(current_token, ['case', 'default'])) {
|
this.print_newline();
|
if (!this._flags.case_block && (this._flags.case_body || this._options.jslint_happy)) {
|
// switch cases following one another
|
this.deindent();
|
}
|
this._flags.case_body = false;
|
|
this.print_token(current_token);
|
this._flags.in_case = true;
|
return;
|
}
|
|
if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) {
|
if (!this.start_of_object_property()) {
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
}
|
|
if (reserved_word(current_token, 'function')) {
|
if (in_array(this._flags.last_token.text, ['}', ';']) ||
|
(this._output.just_added_newline() && !(in_array(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) || this._flags.last_token.type === TOKEN.OPERATOR))) {
|
// make sure there is a nice clean space of at least one blank line
|
// before a new function definition
|
if (!this._output.just_added_blankline() && !current_token.comments_before) {
|
this.print_newline();
|
this.print_newline(true);
|
}
|
}
|
if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD) {
|
if (reserved_array(this._flags.last_token, ['get', 'set', 'new', 'export']) ||
|
reserved_array(this._flags.last_token, newline_restricted_tokens)) {
|
this._output.space_before_token = true;
|
} else if (reserved_word(this._flags.last_token, 'default') && this._last_last_text === 'export') {
|
this._output.space_before_token = true;
|
} else if (this._flags.last_token.text === 'declare') {
|
// accomodates Typescript declare function formatting
|
this._output.space_before_token = true;
|
} else {
|
this.print_newline();
|
}
|
} else if (this._flags.last_token.type === TOKEN.OPERATOR || this._flags.last_token.text === '=') {
|
// foo = function
|
this._output.space_before_token = true;
|
} else if (!this._flags.multiline_frame && (is_expression(this._flags.mode) || is_array(this._flags.mode))) {
|
// (function
|
} else {
|
this.print_newline();
|
}
|
|
this.print_token(current_token);
|
this._flags.last_word = current_token.text;
|
return;
|
}
|
|
var prefix = 'NONE';
|
|
if (this._flags.last_token.type === TOKEN.END_BLOCK) {
|
|
if (this._previous_flags.inline_frame) {
|
prefix = 'SPACE';
|
} else if (!reserved_array(current_token, ['else', 'catch', 'finally', 'from'])) {
|
prefix = 'NEWLINE';
|
} else {
|
if (this._options.brace_style === "expand" ||
|
this._options.brace_style === "end-expand" ||
|
(this._options.brace_style === "none" && current_token.newlines)) {
|
prefix = 'NEWLINE';
|
} else {
|
prefix = 'SPACE';
|
this._output.space_before_token = true;
|
}
|
}
|
} else if (this._flags.last_token.type === TOKEN.SEMICOLON && this._flags.mode === MODE.BlockStatement) {
|
// TODO: Should this be for STATEMENT as well?
|
prefix = 'NEWLINE';
|
} else if (this._flags.last_token.type === TOKEN.SEMICOLON && is_expression(this._flags.mode)) {
|
prefix = 'SPACE';
|
} else if (this._flags.last_token.type === TOKEN.STRING) {
|
prefix = 'NEWLINE';
|
} else if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD ||
|
(this._flags.last_token.text === '*' &&
|
(in_array(this._last_last_text, ['function', 'yield']) ||
|
(this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))) {
|
prefix = 'SPACE';
|
} else if (this._flags.last_token.type === TOKEN.START_BLOCK) {
|
if (this._flags.inline_frame) {
|
prefix = 'SPACE';
|
} else {
|
prefix = 'NEWLINE';
|
}
|
} else if (this._flags.last_token.type === TOKEN.END_EXPR) {
|
this._output.space_before_token = true;
|
prefix = 'NEWLINE';
|
}
|
|
if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') {
|
if (this._flags.inline_frame || this._flags.last_token.text === 'else' || this._flags.last_token.text === 'export') {
|
prefix = 'SPACE';
|
} else {
|
prefix = 'NEWLINE';
|
}
|
|
}
|
|
if (reserved_array(current_token, ['else', 'catch', 'finally'])) {
|
if ((!(this._flags.last_token.type === TOKEN.END_BLOCK && this._previous_flags.mode === MODE.BlockStatement) ||
|
this._options.brace_style === "expand" ||
|
this._options.brace_style === "end-expand" ||
|
(this._options.brace_style === "none" && current_token.newlines)) &&
|
!this._flags.inline_frame) {
|
this.print_newline();
|
} else {
|
this._output.trim(true);
|
var line = this._output.current_line;
|
// If we trimmed and there's something other than a close block before us
|
// put a newline back in. Handles '} // comment' scenario.
|
if (line.last() !== '}') {
|
this.print_newline();
|
}
|
this._output.space_before_token = true;
|
}
|
} else if (prefix === 'NEWLINE') {
|
if (reserved_array(this._flags.last_token, special_words)) {
|
// no newline between 'return nnn'
|
this._output.space_before_token = true;
|
} else if (this._flags.last_token.text === 'declare' && reserved_array(current_token, ['var', 'let', 'const'])) {
|
// accomodates Typescript declare formatting
|
this._output.space_before_token = true;
|
} else if (this._flags.last_token.type !== TOKEN.END_EXPR) {
|
if ((this._flags.last_token.type !== TOKEN.START_EXPR || !reserved_array(current_token, ['var', 'let', 'const'])) && this._flags.last_token.text !== ':') {
|
// no need to force newline on 'var': for (var x = 0...)
|
if (reserved_word(current_token, 'if') && reserved_word(current_token.previous, 'else')) {
|
// no newline for } else if {
|
this._output.space_before_token = true;
|
} else {
|
this.print_newline();
|
}
|
}
|
} else if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') {
|
this.print_newline();
|
}
|
} else if (this._flags.multiline_frame && is_array(this._flags.mode) && this._flags.last_token.text === ',' && this._last_last_text === '}') {
|
this.print_newline(); // }, in lists get a newline treatment
|
} else if (prefix === 'SPACE') {
|
this._output.space_before_token = true;
|
}
|
if (current_token.previous && (current_token.previous.type === TOKEN.WORD || current_token.previous.type === TOKEN.RESERVED)) {
|
this._output.space_before_token = true;
|
}
|
this.print_token(current_token);
|
this._flags.last_word = current_token.text;
|
|
if (current_token.type === TOKEN.RESERVED) {
|
if (current_token.text === 'do') {
|
this._flags.do_block = true;
|
} else if (current_token.text === 'if') {
|
this._flags.if_block = true;
|
} else if (current_token.text === 'import') {
|
this._flags.import_block = true;
|
} else if (this._flags.import_block && reserved_word(current_token, 'from')) {
|
this._flags.import_block = false;
|
}
|
}
|
};
|
|
Beautifier.prototype.handle_semicolon = function(current_token) {
|
if (this.start_of_statement(current_token)) {
|
// The conditional starts the statement if appropriate.
|
// Semicolon can be the start (and end) of a statement
|
this._output.space_before_token = false;
|
} else {
|
this.handle_whitespace_and_comments(current_token);
|
}
|
|
var next_token = this._tokens.peek();
|
while (this._flags.mode === MODE.Statement &&
|
!(this._flags.if_block && reserved_word(next_token, 'else')) &&
|
!this._flags.do_block) {
|
this.restore_mode();
|
}
|
|
// hacky but effective for the moment
|
if (this._flags.import_block) {
|
this._flags.import_block = false;
|
}
|
this.print_token(current_token);
|
};
|
|
Beautifier.prototype.handle_string = function(current_token) {
|
if (current_token.text.startsWith("`") && current_token.newlines === 0 && current_token.whitespace_before === '' && (current_token.previous.text === ')' || this._flags.last_token.type === TOKEN.WORD)) {
|
//Conditional for detectign backtick strings
|
} else if (this.start_of_statement(current_token)) {
|
// The conditional starts the statement if appropriate.
|
// One difference - strings want at least a space before
|
this._output.space_before_token = true;
|
} else {
|
this.handle_whitespace_and_comments(current_token);
|
if (this._flags.last_token.type === TOKEN.RESERVED || this._flags.last_token.type === TOKEN.WORD || this._flags.inline_frame) {
|
this._output.space_before_token = true;
|
} else if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR || this._flags.last_token.type === TOKEN.EQUALS || this._flags.last_token.type === TOKEN.OPERATOR) {
|
if (!this.start_of_object_property()) {
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
} else if ((current_token.text.startsWith("`") && this._flags.last_token.type === TOKEN.END_EXPR && (current_token.previous.text === ']' || current_token.previous.text === ')') && current_token.newlines === 0)) {
|
this._output.space_before_token = true;
|
} else {
|
this.print_newline();
|
}
|
}
|
this.print_token(current_token);
|
};
|
|
Beautifier.prototype.handle_equals = function(current_token) {
|
if (this.start_of_statement(current_token)) {
|
// The conditional starts the statement if appropriate.
|
} else {
|
this.handle_whitespace_and_comments(current_token);
|
}
|
|
if (this._flags.declaration_statement) {
|
// just got an '=' in a var-line, different formatting/line-breaking, etc will now be done
|
this._flags.declaration_assignment = true;
|
}
|
this._output.space_before_token = true;
|
this.print_token(current_token);
|
this._output.space_before_token = true;
|
};
|
|
Beautifier.prototype.handle_comma = function(current_token) {
|
this.handle_whitespace_and_comments(current_token, true);
|
|
this.print_token(current_token);
|
this._output.space_before_token = true;
|
if (this._flags.declaration_statement) {
|
if (is_expression(this._flags.parent.mode)) {
|
// do not break on comma, for(var a = 1, b = 2)
|
this._flags.declaration_assignment = false;
|
}
|
|
if (this._flags.declaration_assignment) {
|
this._flags.declaration_assignment = false;
|
this.print_newline(false, true);
|
} else if (this._options.comma_first) {
|
// for comma-first, we want to allow a newline before the comma
|
// to turn into a newline after the comma, which we will fixup later
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
} else if (this._flags.mode === MODE.ObjectLiteral ||
|
(this._flags.mode === MODE.Statement && this._flags.parent.mode === MODE.ObjectLiteral)) {
|
if (this._flags.mode === MODE.Statement) {
|
this.restore_mode();
|
}
|
|
if (!this._flags.inline_frame) {
|
this.print_newline();
|
}
|
} else if (this._options.comma_first) {
|
// EXPR or DO_BLOCK
|
// for comma-first, we want to allow a newline before the comma
|
// to turn into a newline after the comma, which we will fixup later
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
};
|
|
Beautifier.prototype.handle_operator = function(current_token) {
|
var isGeneratorAsterisk = current_token.text === '*' &&
|
(reserved_array(this._flags.last_token, ['function', 'yield']) ||
|
(in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.COMMA, TOKEN.END_BLOCK, TOKEN.SEMICOLON]))
|
);
|
var isUnary = in_array(current_token.text, ['-', '+']) && (
|
in_array(this._flags.last_token.type, [TOKEN.START_BLOCK, TOKEN.START_EXPR, TOKEN.EQUALS, TOKEN.OPERATOR]) ||
|
in_array(this._flags.last_token.text, line_starters) ||
|
this._flags.last_token.text === ','
|
);
|
|
if (this.start_of_statement(current_token)) {
|
// The conditional starts the statement if appropriate.
|
} else {
|
var preserve_statement_flags = !isGeneratorAsterisk;
|
this.handle_whitespace_and_comments(current_token, preserve_statement_flags);
|
}
|
|
if (reserved_array(this._flags.last_token, special_words)) {
|
// "return" had a special handling in TK_WORD. Now we need to return the favor
|
this._output.space_before_token = true;
|
this.print_token(current_token);
|
return;
|
}
|
|
// hack for actionscript's import .*;
|
if (current_token.text === '*' && this._flags.last_token.type === TOKEN.DOT) {
|
this.print_token(current_token);
|
return;
|
}
|
|
if (current_token.text === '::') {
|
// no spaces around exotic namespacing syntax operator
|
this.print_token(current_token);
|
return;
|
}
|
|
// Allow line wrapping between operators when operator_position is
|
// set to before or preserve
|
if (this._flags.last_token.type === TOKEN.OPERATOR && in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) {
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
|
if (current_token.text === ':' && this._flags.in_case) {
|
this.print_token(current_token);
|
|
this._flags.in_case = false;
|
this._flags.case_body = true;
|
if (this._tokens.peek().type !== TOKEN.START_BLOCK) {
|
this.indent();
|
this.print_newline();
|
this._flags.case_block = false;
|
} else {
|
this._flags.case_block = true;
|
this._output.space_before_token = true;
|
}
|
return;
|
}
|
|
var space_before = true;
|
var space_after = true;
|
var in_ternary = false;
|
if (current_token.text === ':') {
|
if (this._flags.ternary_depth === 0) {
|
// Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant.
|
space_before = false;
|
} else {
|
this._flags.ternary_depth -= 1;
|
in_ternary = true;
|
}
|
} else if (current_token.text === '?') {
|
this._flags.ternary_depth += 1;
|
}
|
|
// let's handle the operator_position option prior to any conflicting logic
|
if (!isUnary && !isGeneratorAsterisk && this._options.preserve_newlines && in_array(current_token.text, positionable_operators)) {
|
var isColon = current_token.text === ':';
|
var isTernaryColon = (isColon && in_ternary);
|
var isOtherColon = (isColon && !in_ternary);
|
|
switch (this._options.operator_position) {
|
case OPERATOR_POSITION.before_newline:
|
// if the current token is : and it's not a ternary statement then we set space_before to false
|
this._output.space_before_token = !isOtherColon;
|
|
this.print_token(current_token);
|
|
if (!isColon || isTernaryColon) {
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
|
this._output.space_before_token = true;
|
return;
|
|
case OPERATOR_POSITION.after_newline:
|
// if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement,
|
// then print a newline.
|
|
this._output.space_before_token = true;
|
|
if (!isColon || isTernaryColon) {
|
if (this._tokens.peek().newlines) {
|
this.print_newline(false, true);
|
} else {
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
} else {
|
this._output.space_before_token = false;
|
}
|
|
this.print_token(current_token);
|
|
this._output.space_before_token = true;
|
return;
|
|
case OPERATOR_POSITION.preserve_newline:
|
if (!isOtherColon) {
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
|
// if we just added a newline, or the current token is : and it's not a ternary statement,
|
// then we set space_before to false
|
space_before = !(this._output.just_added_newline() || isOtherColon);
|
|
this._output.space_before_token = space_before;
|
this.print_token(current_token);
|
this._output.space_before_token = true;
|
return;
|
}
|
}
|
|
if (isGeneratorAsterisk) {
|
this.allow_wrap_or_preserved_newline(current_token);
|
space_before = false;
|
var next_token = this._tokens.peek();
|
space_after = next_token && in_array(next_token.type, [TOKEN.WORD, TOKEN.RESERVED]);
|
} else if (current_token.text === '...') {
|
this.allow_wrap_or_preserved_newline(current_token);
|
space_before = this._flags.last_token.type === TOKEN.START_BLOCK;
|
space_after = false;
|
} else if (in_array(current_token.text, ['--', '++', '!', '~']) || isUnary) {
|
// unary operators (and binary +/- pretending to be unary) special cases
|
if (this._flags.last_token.type === TOKEN.COMMA || this._flags.last_token.type === TOKEN.START_EXPR) {
|
this.allow_wrap_or_preserved_newline(current_token);
|
}
|
|
space_before = false;
|
space_after = false;
|
|
// http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1
|
// if there is a newline between -- or ++ and anything else we should preserve it.
|
if (current_token.newlines && (current_token.text === '--' || current_token.text === '++' || current_token.text === '~')) {
|
this.print_newline(false, true);
|
}
|
|
if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) {
|
// for (;; ++i)
|
// ^^^
|
space_before = true;
|
}
|
|
if (this._flags.last_token.type === TOKEN.RESERVED) {
|
space_before = true;
|
} else if (this._flags.last_token.type === TOKEN.END_EXPR) {
|
space_before = !(this._flags.last_token.text === ']' && (current_token.text === '--' || current_token.text === '++'));
|
} else if (this._flags.last_token.type === TOKEN.OPERATOR) {
|
// a++ + ++b;
|
// a - -b
|
space_before = in_array(current_token.text, ['--', '-', '++', '+']) && in_array(this._flags.last_token.text, ['--', '-', '++', '+']);
|
// + and - are not unary when preceeded by -- or ++ operator
|
// a-- + b
|
// a * +b
|
// a - -b
|
if (in_array(current_token.text, ['+', '-']) && in_array(this._flags.last_token.text, ['--', '++'])) {
|
space_after = true;
|
}
|
}
|
|
|
if (((this._flags.mode === MODE.BlockStatement && !this._flags.inline_frame) || this._flags.mode === MODE.Statement) &&
|
(this._flags.last_token.text === '{' || this._flags.last_token.text === ';')) {
|
// { foo; --i }
|
// foo(); --bar;
|
this.print_newline();
|
}
|
}
|
|
this._output.space_before_token = this._output.space_before_token || space_before;
|
this.print_token(current_token);
|
this._output.space_before_token = space_after;
|
};
|
|
Beautifier.prototype.handle_block_comment = function(current_token, preserve_statement_flags) {
|
if (this._output.raw) {
|
this._output.add_raw_token(current_token);
|
if (current_token.directives && current_token.directives.preserve === 'end') {
|
// If we're testing the raw output behavior, do not allow a directive to turn it off.
|
this._output.raw = this._options.test_output_raw;
|
}
|
return;
|
}
|
|
if (current_token.directives) {
|
this.print_newline(false, preserve_statement_flags);
|
this.print_token(current_token);
|
if (current_token.directives.preserve === 'start') {
|
this._output.raw = true;
|
}
|
this.print_newline(false, true);
|
return;
|
}
|
|
// inline block
|
if (!acorn.newline.test(current_token.text) && !current_token.newlines) {
|
this._output.space_before_token = true;
|
this.print_token(current_token);
|
this._output.space_before_token = true;
|
return;
|
} else {
|
this.print_block_commment(current_token, preserve_statement_flags);
|
}
|
};
|
|
Beautifier.prototype.print_block_commment = function(current_token, preserve_statement_flags) {
|
var lines = split_linebreaks(current_token.text);
|
var j; // iterator for this case
|
var javadoc = false;
|
var starless = false;
|
var lastIndent = current_token.whitespace_before;
|
var lastIndentLength = lastIndent.length;
|
|
// block comment starts with a new line
|
this.print_newline(false, preserve_statement_flags);
|
|
// first line always indented
|
this.print_token_line_indentation(current_token);
|
this._output.add_token(lines[0]);
|
this.print_newline(false, preserve_statement_flags);
|
|
|
if (lines.length > 1) {
|
lines = lines.slice(1);
|
javadoc = all_lines_start_with(lines, '*');
|
starless = each_line_matches_indent(lines, lastIndent);
|
|
if (javadoc) {
|
this._flags.alignment = 1;
|
}
|
|
for (j = 0; j < lines.length; j++) {
|
if (javadoc) {
|
// javadoc: reformat and re-indent
|
this.print_token_line_indentation(current_token);
|
this._output.add_token(ltrim(lines[j]));
|
} else if (starless && lines[j]) {
|
// starless: re-indent non-empty content, avoiding trim
|
this.print_token_line_indentation(current_token);
|
this._output.add_token(lines[j].substring(lastIndentLength));
|
} else {
|
// normal comments output raw
|
this._output.current_line.set_indent(-1);
|
this._output.add_token(lines[j]);
|
}
|
|
// for comments on their own line or more than one line, make sure there's a new line after
|
this.print_newline(false, preserve_statement_flags);
|
}
|
|
this._flags.alignment = 0;
|
}
|
};
|
|
|
Beautifier.prototype.handle_comment = function(current_token, preserve_statement_flags) {
|
if (current_token.newlines) {
|
this.print_newline(false, preserve_statement_flags);
|
} else {
|
this._output.trim(true);
|
}
|
|
this._output.space_before_token = true;
|
this.print_token(current_token);
|
this.print_newline(false, preserve_statement_flags);
|
};
|
|
Beautifier.prototype.handle_dot = function(current_token) {
|
if (this.start_of_statement(current_token)) {
|
// The conditional starts the statement if appropriate.
|
} else {
|
this.handle_whitespace_and_comments(current_token, true);
|
}
|
|
if (reserved_array(this._flags.last_token, special_words)) {
|
this._output.space_before_token = false;
|
} else {
|
// allow preserved newlines before dots in general
|
// force newlines on dots after close paren when break_chained - for bar().baz()
|
this.allow_wrap_or_preserved_newline(current_token,
|
this._flags.last_token.text === ')' && this._options.break_chained_methods);
|
}
|
|
// Only unindent chained method dot if this dot starts a new line.
|
// Otherwise the automatic extra indentation removal will handle the over indent
|
if (this._options.unindent_chained_methods && this._output.just_added_newline()) {
|
this.deindent();
|
}
|
|
this.print_token(current_token);
|
};
|
|
Beautifier.prototype.handle_unknown = function(current_token, preserve_statement_flags) {
|
this.print_token(current_token);
|
|
if (current_token.text[current_token.text.length - 1] === '\n') {
|
this.print_newline(false, preserve_statement_flags);
|
}
|
};
|
|
Beautifier.prototype.handle_eof = function(current_token) {
|
// Unwind any open statements
|
while (this._flags.mode === MODE.Statement) {
|
this.restore_mode();
|
}
|
this.handle_whitespace_and_comments(current_token);
|
};
|
|
module.exports.Beautifier = Beautifier;
|
