jsx_boolean_value

var JsxBooleanValueRule = rule.Rule{
	Name: "react/jsx-boolean-value",
	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
		mode := "never"
		var exceptions map[string]bool
		assumeUndefinedIsFalse := false

		if arr, ok := options.([]interface{}); ok {
			if len(arr) > 0 {
				if m, ok := arr[0].(string); ok {
					mode = m
				}
			}
			if len(arr) > 1 {
				if optsObj, ok := arr[1].(map[string]interface{}); ok {

					exKey := "always"
					if mode == "always" {
						exKey = "never"
					}
					if exList, ok := optsObj[exKey]; ok {
						if exArr, ok := exList.([]interface{}); ok {
							exceptions = make(map[string]bool)
							for _, item := range exArr {
								if name, ok := item.(string); ok {
									exceptions[name] = true
								}
							}
						}
					}
					if v, ok := optsObj["assumeUndefinedIsFalse"]; ok {
						if b, ok := v.(bool); ok {
							assumeUndefinedIsFalse = b
						}
					}
				}
			}
		} else {

			if m, ok := options.(string); ok {
				mode = m
			}
		}

		return rule.RuleListeners{
			ast.KindJsxAttribute: func(node *ast.Node) {
				attr := node.AsJsxAttribute()
				nameNode := attr.Name()
				if nameNode == nil {
					return
				}

				propName := ""
				if nameNode.Kind == ast.KindIdentifier {
					propName = nameNode.AsIdentifier().Text
				} else {
					trimmed := utils.TrimNodeTextRange(ctx.SourceFile, nameNode)
					propName = ctx.SourceFile.Text()[trimmed.Pos():trimmed.End()]
				}

				effectiveMode := mode
				if exceptions != nil && exceptions[propName] {
					if mode == "always" {
						effectiveMode = "never"
					} else {
						effectiveMode = "always"
					}
				}

				initializer := attr.Initializer

				if effectiveMode == "never" {

					if initializer != nil && isExpressionTrue(initializer) {

						nameEnd := nameNode.End()
						initEnd := initializer.End()
						fixRange := core.NewTextRange(nameEnd, initEnd)

						ctx.ReportNodeWithFixes(node, rule.RuleMessage{
							Id:          "omitBoolean",
							Description: "Value must be omitted for boolean attribute `" + propName + "`",
						}, rule.RuleFix{
							Text:  "",
							Range: fixRange,
						})
					}

					if assumeUndefinedIsFalse && initializer != nil && isExpressionFalse(initializer) {
						trimmed := utils.TrimNodeTextRange(ctx.SourceFile, node)

						text := ctx.SourceFile.Text()
						start := trimmed.Pos()
						for start > 0 && (text[start-1] == ' ' || text[start-1] == '\t') {
							start--
						}
						fixRange := core.NewTextRange(start, trimmed.End())

						ctx.ReportNodeWithFixes(node, rule.RuleMessage{
							Id:          "omitPropAndBoolean",
							Description: "Value must be omitted for `false` attribute: `" + propName + "`",
						}, rule.RuleFix{
							Text:  "",
							Range: fixRange,
						})
					}
				} else {

					if initializer == nil {

						nameEnd := nameNode.End()
						fixRange := core.NewTextRange(nameEnd, nameEnd)

						ctx.ReportNodeWithFixes(node, rule.RuleMessage{
							Id:          "setBoolean",
							Description: "Value must be set for boolean attribute `" + propName + "`",
						}, rule.RuleFix{
							Text:  "={true}",
							Range: fixRange,
						})
					}
				}
			},
		}
	},
}