jsx_indent_props

var JsxIndentPropsRule = rule.Rule{
	Name: "react/jsx-indent-props",
	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
		indentType, indentSize, indentChar, indentIsFirst, ignoreTernaryOperator := parseOptions(options)

		text := ctx.SourceFile.Text()
		lineMap := ctx.SourceFile.ECMALineMap()

		firstNonWhitespaceCharOnLine := func(pos int) byte {
			start := reactutil.IndentLineStart(lineMap, pos)
			for i := start; i < len(text); i++ {
				c := text[i]
				if c == ' ' || c == '\t' {
					continue
				}
				if c == '\n' || c == '\r' {
					return 0
				}
				return c
			}
			return 0
		}

		firstLineContainsBracket := func(node *ast.Node) bool {
			trimmed := utils.TrimNodeTextRange(ctx.SourceFile, node)
			lineStart := reactutil.IndentLineStart(lineMap, trimmed.Pos())
			end := trimmed.End()
			for i := lineStart; i < end && i < len(text); i++ {
				c := text[i]
				if c == '\n' {
					break
				}
				if c == '<' {
					return true
				}
			}
			return false
		}

		check := func(node *ast.Node) {
			var props []*ast.Node
			switch node.Kind {
			case ast.KindJsxOpeningElement:
				opening := node.AsJsxOpeningElement()
				if opening.Attributes != nil {
					attrs := opening.Attributes.AsJsxAttributes()
					if attrs != nil && attrs.Properties != nil {
						props = attrs.Properties.Nodes
					}
				}
			case ast.KindJsxSelfClosingElement:
				self := node.AsJsxSelfClosingElement()
				if self.Attributes != nil {
					attrs := self.Attributes.AsJsxAttributes()
					if attrs != nil && attrs.Properties != nil {
						props = attrs.Properties.Nodes
					}
				}
			}
			if len(props) == 0 {
				return
			}

			openingTrimmed := utils.TrimNodeTextRange(ctx.SourceFile, node)
			openingStart := openingTrimmed.Pos()

			leadChar := firstNonWhitespaceCharOnLine(openingStart)
			isUsingOperator := leadChar == '?' || leadChar == ':'

			elementIndent := reactutil.IndentLeading(text, lineMap, openingStart, indentChar)

			var propIndent int
			if indentIsFirst {

				propIndent = reactutil.NodeStartUTF16Column(ctx.SourceFile, props[0])
			} else {
				propIndent = elementIndent + indentSize
			}

			nestedIndent := propIndent
			bumpApplied := false

			for _, prop := range props {

				if firstLineContainsBracket(prop) {
					isUsingOperator = false
				}

				if !reactutil.IsNodeFirstInLine(ctx.SourceFile, prop) {
					continue
				}

				if !bumpApplied && isUsingOperator && !indentIsFirst && !ignoreTernaryOperator {
					nestedIndent += indentSize
					bumpApplied = true
					isUsingOperator = false
				}

				actualIndent := reactutil.NodeStartIndent(ctx.SourceFile, prop, indentChar)
				if actualIndent != nestedIndent {
					reactutil.ReportIndentReplaceLeading(ctx, prop, nestedIndent, actualIndent, indentChar, indentType)
				}
			}
		}

		return rule.RuleListeners{
			ast.KindJsxOpeningElement:     check,
			ast.KindJsxSelfClosingElement: check,
		}
	},
}