if !exists('g:polyglot_disabled') || !(index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'typescript') != -1 || index(g:polyglot_disabled, 'jsx') != -1)
if exists('*shiftwidth')
function! s:sw()
return shiftwidth()
endfunction
else
function! s:sw()
return &sw
endfunction
endif
" Regexp for the start tag
let s:start_tag = '<\_s*\%(>\|\${\|\%(\<[-:._$A-Za-z0-9]\+\>\)\)'
" Regexp for the end tag
let s:end_tag = '\%(<\_s*/\_s*\%(\<[-:._$A-Za-z0-9]\+\>\)\_s*>\|/\_s*>\)'
" Get the syntax stack at the given position
function s:syntax_stack_at(lnum, col)
return map(synstack(a:lnum, a:col), 'synIDattr(v:val, "name")')
endfunction
" Get the syntax at the given position
function s:syntax_at(lnum, col)
return synIDattr(synID(a:lnum, a:col, 1), 'name')
endfunction
" Get the start col of the non-space charactor
function s:start_col(lnum)
return len(matchstr(getline(a:lnum), '^\s*')) + 1
endfunction
" Get the end col of the non-space charactor
function s:end_col(lnum)
return len(substitute(getline(a:lnum), '\s*$', '', 'g'))
endfunction
" Get the start syntax of a given line number
function s:start_syntax(lnum)
return s:syntax_at(a:lnum, s:start_col(a:lnum))
endfunction
" Get the end syntax of a given line number
function s:end_syntax(lnum)
let end_col = len(substitute(getline(a:lnum), '\s*$', '', 'g'))
return s:syntax_at(a:lnum, end_col)
endfunction
" The skip function for searchpair
function s:skip_if_not(current_lnum, ...)
" Skip the match in current line
if line('.') == a:current_lnum
return 1
endif
let syntax = s:syntax_at(line('.'), col('.'))
return syntax !~? join(a:000, '\|')
endfunction
" Whether the specified stytax group is an jsx-related syntax
function s:is_jsx(syntax_name)
return a:syntax_name =~ '^jsx' && a:syntax_name !=? 'jsxEscapeJs'
endfunction
" Whether the specified line is start with jsx-related syntax
function s:start_with_jsx(lnum)
let start_syntax = s:start_syntax(a:lnum)
return s:is_jsx(start_syntax)
endfunction
" Whether the specified line is end with jsx-related syntax
function s:end_with_jsx(lnum)
let end_syntax = s:end_syntax(a:lnum)
return s:is_jsx(end_syntax)
endfunction
" Whether the specified line is comment related syntax
function s:is_comment(syntax)
return a:syntax =~? 'comment'
endfunction
" Whether the specified line is embedded comment in jsxTag
function s:is_embedded_comment(lnum)
let start_col = s:start_col(a:lnum)
let syntax_stack = s:syntax_stack_at(a:lnum, start_col)
let last = get(syntax_stack, -1)
let last_2nd = get(syntax_stack, -2)
" Patch code for pangloss/vim-javascript
" <div
" /* hello */ <-- syntax stack is [..., jsxTag, jsComment, jsComment]
" >
if last_2nd =~ 'comment'
let last_2nd = get(syntax_stack, -3)
endif
return last =~? 'comment' && last_2nd =~? 'jsxTag' &&
\ trim(getline(a:lnum)) =~ '\%(^/[*/]\)\|\%(\*/$\)'
endfunction
" Whether the specified stytax group is the opening tag
function s:is_opening_tag(syntax)
return a:syntax =~? 'jsxOpenPunct'
endfunction
" Whether the specified stytax group is the closing tag
function s:is_closing_tag(syntax)
return a:syntax =~? 'jsxClose'
endfunction
" Whether the specified stytax group is the jsxAttrib
function s:is_jsx_attr(syntax)
return a:syntax =~? 'jsxAttrib'
endfunction
" Whether the specified syntax group is the jsxElement
function s:is_jsx_element(syntax)
return a:syntax =~? 'jsxElement'
endfunction
" Whether the specified syntax group is the jsxTag
function s:is_jsx_tag(syntax)
return a:syntax =~? 'jsxTag'
endfunction
" Whether the specified syntax group is the jsxBraces
function s:is_jsx_brace(syntax)
return a:syntax =~? 'jsxBraces'
endfunction
" Whether the specified syntax group is the jsxComment
function s:is_jsx_comment(syntax)
return a:syntax =~? 'jsxComment'
endfunction
" Whether the specified syntax group is the jsxComment
function s:is_jsx_backticks(syntax)
return a:syntax =~? 'jsxBackticks'
endfunction
" Get the prvious line number
function s:prev_lnum(lnum)
return prevnonblank(a:lnum - 1)
endfunction
" Given a lnum and get the information of its previous line
function s:prev_info(lnum)
let prev_lnum = s:prev_lnum(a:lnum)
let prev_start_syntax = s:start_syntax(prev_lnum)
let prev_end_syntax = s:end_syntax(prev_lnum)
return [prev_lnum, prev_start_syntax, prev_end_syntax]
endfunction
" Get the length difference between syntax stack a and b
function s:syntax_stack_length_compare(lnum_a, col_a, lnum_b, col_b)
let stack_a = s:syntax_stack_at(a:lnum_a, a:col_a)
let stack_b = s:syntax_stack_at(a:lnum_b, a:col_b)
return len(stack_a) - len(stack_b)
endfunction
" Determine whether child is a element of parent
function s:is_element_of(parent_lnum, child_lnum)
let parent_stack = s:syntax_stack_at(a:parent_lnum, s:start_col(a:parent_lnum))
let child_stack = s:syntax_stack_at(a:child_lnum, s:start_col(a:child_lnum))
let element_index = len(child_stack) - index(reverse(child_stack), 'jsxElement')
let rest = parent_stack[element_index:]
return index(rest, 'jsxElement') == -1
endfunction
" Compute the indention of the opening tag
function s:jsx_indent_opening_tag(lnum)
let [prev_lnum, prev_start_syntax, prev_end_syntax] = s:prev_info(a:lnum)
" If current line is start with >
if trim(getline(a:lnum)) =~ '^>'
let pair_line = searchpair('<', '', '>', 'bW', 's:skip_if_not(a:lnum, "jsxOpenPunct", "jsxClose")')
return indent(pair_line)
endif
" If both the start and the end of the previous line are not jsx-related syntax
" return (
" <div></div> <--
" )
if !s:end_with_jsx(prev_lnum) && !s:start_with_jsx(prev_lnum)
" return -1, so that it will use the default js indent function
return -1
endif
" If the end of the previous line is not jsx-related syntax
" [
" <div></div>,
" <div></div> <--
" ]
" should not affect
" <div
" render={() => (
" <div> <--
" </div>
" )}
" >
" </div>
" <div>
" {items.map(() => (
" <Item /> <--
" ))}
" </div>
if !s:end_with_jsx(prev_lnum) &&
\ !s:is_jsx_attr(prev_start_syntax) &&
\ !s:is_jsx_brace(prev_start_syntax)
return indent(prev_lnum)
endif
" If the start of the previous line is not jsx-related syntax
" return <div>
" <div></div> <--
" </div>
if !s:start_with_jsx(prev_lnum)
return indent(prev_lnum) + s:sw()
endif
endif
" <div>
" <span>
" </span>
" <div> <--
" </div>
" </div>
if s:is_closing_tag(prev_start_syntax)
return indent(prev_lnum)
endif
" If the previous line is end with a closing tag
" <div>
" <br />
" <div></div> <--
" </div>
" should not affect case like
" <div><br />
" <span> <--
" </div>
if s:is_closing_tag(prev_end_syntax) &&
\ s:syntax_stack_length_compare(
\ prev_lnum, s:start_col(prev_lnum), prev_lnum, s:end_col(prev_lnum)) == 2
return indent(prev_lnum)
endif
" If the start of the previous line is the jsxElement
" <div>
" hello
" <div></div> <--
" </div>
if s:is_jsx_element(prev_start_syntax) ||
\ s:is_jsx_comment(prev_start_syntax)
return indent(prev_lnum)
endif
" If the start of the prvious line is the jsxBraces {
" <div>
" {foo}
" <div></div> <--
" </div>
" should not affect case like
" <div>
" {
" <div></div> <--
" }
" </div>
if s:is_jsx_brace(prev_start_syntax) &&
\ trim(getline(prev_lnum)) =~ '^[$]\?{' &&
\ s:syntax_stack_length_compare(
\ prev_lnum, s:start_col(prev_lnum), a:lnum, s:start_col(a:lnum)) == -2
return indent(prev_lnum)
endif
" If the start of the prvious line is the jsxBraces }
" <div>
" {
" foo
" }
" <div></div> <--
" </div>
if s:is_jsx_brace(prev_start_syntax) &&
\ trim(getline(prev_lnum)) =~ '}' &&
\ s:syntax_stack_length_compare(
\ prev_lnum, s:start_col(prev_lnum), a:lnum, s:start_col(a:lnum)) == -3
return indent(prev_lnum)
endif
" Otherwise, indent s:sw() spaces
return indent(prev_lnum) + s:sw()
endfunction
" Compute the indention of the closing tag
function s:jsx_indent_closing_tag(lnum)
let pair_line = searchpair(s:start_tag, '', s:end_tag, 'bW', 's:skip_if_not(a:lnum, "jsxOpenPunct", "jsxClose")')
return pair_line ? indent(pair_line) : indent(a:lnum)
endfunction
" Compute the indention of the jsxAttrib
function s:jsx_indent_attr(lnum)
let [prev_lnum, prev_start_syntax, prev_end_syntax] = s:prev_info(a:lnum)
" If the start of the previous line is not jsx-related syntax
" return <div
" attr="hello" <--
" >
" should not affect
" <div
" // comment here
" attr="hello"
" >
" </div>
if !s:start_with_jsx(prev_lnum) &&
\ !s:is_comment(prev_start_syntax)
return indent(prev_lnum) + s:sw()
endif
" If the start of the previous line is the opening tag
" <div
" title="title" <--
" >
if s:is_opening_tag(prev_start_syntax)
return indent(prev_lnum) + s:sw()
endif
" Otherwise, align the attribute with its previous line
return indent(prev_lnum)
endfunction
" Compute the indentation of the jsxElement
function s:jsx_indent_element(lnum)
let [prev_lnum, prev_start_syntax, prev_end_syntax] = s:prev_info(a:lnum)
" Fix test case like
" <div|> <-- press enter
" should indent as
" <div
" > <--
if trim(getline(a:lnum)) =~ '^>' && !s:is_opening_tag(prev_end_syntax)
return indent(prev_lnum)
endif
" If the start of the previous line is start with >
" <div
" attr="foo"
" >
" text <--
" </div>
if s:is_opening_tag(prev_start_syntax) &&
\ trim(getline(prev_lnum)) =~ '^>$'
return indent(prev_lnum) + s:sw()
endif
" <div>
" text <--
" </div>
" should not affect case like
" <div>
" <br />
" hello <--
" </div>
if s:is_opening_tag(prev_start_syntax) &&
\ s:is_element_of(prev_lnum, a:lnum)
return indent(prev_lnum) + s:sw()
endif
" return <div>
" text <--
" </div>
if !s:start_with_jsx(prev_lnum)
return indent(prev_lnum) + s:sw()
endif
" Otherwise, align with the previous line
" <div>
" {foo}
" text <--
" </div>
return indent(prev_lnum)
endfunction
" Compute the indentation of jsxBraces
function s:jsx_indent_brace(lnum)
let [prev_lnum, prev_start_syntax, prev_end_syntax] = s:prev_info(a:lnum)
" If the start of the previous line is start with >
" <div
" attr="foo"
" >
" {foo} <--
" </div>
if s:is_opening_tag(prev_start_syntax) &&
\ trim(getline(prev_lnum)) =~ '^>$'
return indent(prev_lnum) + s:sw()
endif
" <div>
" {foo} <--
" </div>
" should not affect case like
" <div>
" <br />
" {foo} <--
" text
" {foo} <--
" </div>
if s:is_opening_tag(prev_start_syntax) &&
\ s:syntax_stack_length_compare(
\ prev_lnum, s:start_col(prev_lnum), a:lnum, s:start_col(a:lnum)) == 1
return indent(prev_lnum) + s:sw()
endif
" If current line is the close brace }
if trim(getline(a:lnum)) =~ '^}'
let pair_line = searchpair('{', '', '}', 'bW', 's:skip_if_not(a:lnum, "jsxBraces")')
return indent(pair_line)
endif
" return <div>
" {foo} <--
" </div>
" should not affect
" <div
" // js comment
" {...props} <--
" >
" </div>
if !s:start_with_jsx(prev_lnum) &&
\ !s:is_comment(prev_start_syntax)
return indent(prev_lnum) + s:sw()
endif
return indent(prev_lnum)
endfunction
" Compute the indentation of the comment
function s:jsx_indent_comment(lnum)
let [prev_lnum, prev_start_syntax, prev_end_syntax] = s:prev_info(a:lnum)
" If current line is jsxComment
if s:is_jsx_comment(s:start_syntax(a:lnum))
let line = trim(getline(a:lnum))
if line =~ '^<!--'
" Patch code for yajs.vim
" ${logs.map(log => html`
" <${Log} class="log" ...${log} />
" `)} <-- The backtick here is Highlighted as javascriptTemplate
" <!-- <-- Correct the indentation here
if !s:start_with_jsx(prev_lnum) && s:end_with_jsx(prev_lnum)
return indent(prev_lnum)
endif
" Return the element indent for the opening comment
return s:jsx_indent_element(a:lnum)
elseif line =~ '^-->'
" Return the paired indent for the closing comment
let pair_line = searchpair('<!--', '', '-->', 'bW')
return indent(pair_line)
else
if trim(getline(prev_lnum)) =~ '^<!--'
" <!--
" comment <--
" -->
return indent(prev_lnum) + s:sw()
else
" <!--
" comment
" comment <--
" -->
return indent(prev_lnum)
endif
endif
endif
" For comment inside the jsxTag
if s:is_opening_tag(prev_start_syntax)
return indent(prev_lnum) + s:sw()
endif
if trim(getline(a:lnum)) =~ '\*/$'
let pair_line = searchpair('/\*', '', '\*/', 'bW', 's:skip_if_not(a:lnum)')
return indent(pair_line) + 1
endif
return indent(prev_lnum)
endfunction
function s:jsx_indent_backticks(lnum)
let tags = get(g:, 'vim_jsx_pretty_template_tags', ['html', 'jsx'])
let start_tag = '\%(' . join(tags, '\|') . '\)`'
let end_tag = '\%(' . join(tags, '\|') . '\)\@<!`'
let pair_line = searchpair(start_tag, '', end_tag, 'bW', 's:skip_if_not(a:lnum)')
return indent(pair_line)
endfunction
" Compute the indentation for the jsx-related element
function s:jsx_indent(lnum)
let start_syntax = s:start_syntax(a:lnum)
if s:is_opening_tag(start_syntax)
return s:jsx_indent_opening_tag(a:lnum)
elseif s:is_closing_tag(start_syntax)
return s:jsx_indent_closing_tag(a:lnum)
elseif s:is_jsx_attr(start_syntax)
return s:jsx_indent_attr(a:lnum)
elseif s:is_jsx_element(start_syntax)
return s:jsx_indent_element(a:lnum)
elseif s:is_jsx_brace(start_syntax)
return s:jsx_indent_brace(a:lnum)
elseif s:is_jsx_comment(start_syntax)
return s:jsx_indent_comment(a:lnum)
elseif s:is_jsx_backticks(start_syntax)
return s:jsx_indent_backticks(a:lnum)
endif
return -1
endfunction
" Return the jsx context of the specified line
function s:jsx_context(lnum)
if !s:end_with_jsx(prev_lnum)
return 'non-jsx'
endif
let prev_lnum = s:prev_lnum(a:lnum)
let start_syntax = s:start_syntax(prev_lnum)
let end_col = s:end_col(prev_lnum)
let end_syntax_stack = s:syntax_stack_at(prev_lnum, end_col)
let reversed = reverse(end_syntax_stack)
for item in reversed
if item =~? 'jsxEscapeJs'
return 'unknown'
elseif s:is_jsx_element(item) && s:is_jsx(start_syntax) && start_syntax !~? 'jsxEscapeJs'
" <div>
" <br /> <-- press o
" </div>
" --------------------
" <div>
" {
" a > 0 ? 1 <div>|</div> <-- press enter
" }
" </div>
return 'jsxElement'
elseif s:is_jsx_tag(item)
return 'jsxTag'
elseif s:is_jsx_brace(item) && trim(getline(prev_lnum)) =~ '{$'
return 'jsxBraces'
endif
endfor
return 'unknown'
endfunction
function! jsx_pretty#indent#get(js_indent)
" The start column index of the current line (one-based)
let start_col = s:start_col(v:lnum)
" The end column index of the current line (one-based)
let end_col = s:end_col(v:lnum)
if s:start_with_jsx(v:lnum)
let ind = s:jsx_indent(v:lnum)
return ind == -1 ? a:js_indent() : ind
elseif s:is_embedded_comment(v:lnum)
return s:jsx_indent_comment(v:lnum)
else
let line = trim(getline(v:lnum))
let prev_lnum = s:prev_lnum(v:lnum)
" Fix the case where pressing enter at the cursor
" return <div>|</div>
if line =~ '^' . s:end_tag &&
\ s:end_with_jsx(s:prev_lnum(v:lnum))
return s:jsx_indent_closing_tag(v:lnum)
endif
" Fix cases for the new line
if empty(line)
let context = s:jsx_context(v:lnum)
if context == 'jsxElement'
" <div> <-- press o
" </div>
return s:jsx_indent_element(v:lnum)
elseif context == 'jsxTag'
" <div <-- press o
" >
" </div>
" -----------------------
" <div
" attr="attr" <-- press o
" >
" </div>
return s:jsx_indent_attr(v:lnum)
elseif context == 'jsxBraces'
" <div>
" { <-- press o
" }
" </div>
return indent(prev_lnum) + s:sw()
endif
endif
return a:js_indent()
endif
endfunction
endif
