indent.js

A code indenter built to only indent code while preserving everything else.

This tool will not output proper js-lint compatible code (like forcing object properties to be on separate lines). It works with any combination of CSS, JavaScript, HTML, and perhaps even several other languages.

Indent with

Mode

/**
Code taken from js-beautify project
*/
function handle_start_block() {
// Check if this is should be treated as a ObjectLiteral
var next_token = get_token(1);
var second_token = get_token(2);
if (second_token && (
(in_array(second_token.text, [':', ',']) && in_array(next_token.type, ['TK_STRING', 'TK_WORD', 'TK_RESERVED'])) ||
(in_array(next_token.text, ['get', 'set']) && in_array(second_token.type, ['TK_WORD', 'TK_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(last_last_text, ['class', 'interface'])) {
set_mode(MODE.ObjectLiteral);
} else {
set_mode(MODE.BlockStatement);
}
} else if (last_type === 'TK_OPERATOR' && flags.last_text === '=>') {
// arrow function: (param1, paramN) => { statements }
set_mode(MODE.BlockStatement);
} else if (in_array(last_type, ['TK_EQUALS', 'TK_START_EXPR', 'TK_COMMA', 'TK_OPERATOR']) ||
(last_type === 'TK_RESERVED' && in_array(flags.last_text, ['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.
set_mode(MODE.ObjectLiteral);
} else {
set_mode(MODE.BlockStatement);
}

var empty_braces = !next_token.comments_before.length && next_token.text === '}';
var empty_anonymous_function = empty_braces && flags.last_word === 'function' &&
last_type === 'TK_END_EXPR';

if (opt.brace_style === "expand" ||
(opt.brace_style === "none" && current_token.wanted_newline)) {
if (last_type !== 'TK_OPERATOR' &&
(empty_anonymous_function ||
last_type === 'TK_EQUALS' ||
(last_type === 'TK_RESERVED' && is_special_word(flags.last_text) && flags.last_text !== 'else'))) {
output.space_before_token = true;
} else {
print_newline(false, true);
}
} else { // collapse
if (opt.brace_style === 'collapse-preserve-inline') {
// search forward for a newline wanted inside this block
var index = 0;
var check_token = null;
flags.inline_frame = true;
do {
index += 1;
check_token = get_token(index);
if (check_token.wanted_newline) {
    flags.inline_frame = false;
    break;
}
} while (check_token.type !== 'TK_EOF' &&
!(check_token.type === 'TK_END_BLOCK' && check_token.opened === current_token));
}

if (is_array(previous_flags.mode) && (last_type === 'TK_START_EXPR' || last_type === 'TK_COMMA')) {
// if we're preserving inline,
// allow newline between comma and next brace.
if (last_type === 'TK_COMMA' || opt.space_in_paren) {
output.space_before_token = true;
}

if (opt.brace_style === 'collapse-preserve-inline' &&
(last_type === 'TK_COMMA' || (last_type === 'TK_START_EXPR' && flags.inline_frame))) {
allow_wrap_or_preserved_newline();
previous_flags.multiline_frame = previous_flags.multiline_frame || flags.multiline_frame;
flags.multiline_frame = false;
}
} else if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') {
if (last_type === 'TK_START_BLOCK') {
print_newline();
} else {
output.space_before_token = true;
}
}
}
print_token();
indent();
}