diff --git a/CHANGES.md b/CHANGES.md index bdfbc432e..eb5cf76fc 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -1,5 +1,6 @@ # 0.17.0 +* Support custom `data-*` attributes in DOM JSX, including optional string values (@anmonteiro in https://github.com/reasonml/reason-react/pull/933) * Upgrade `ppxlib` lower bound to `0.36` (@anmonteiro in https://github.com/reasonml/reason-react/pull/883) * Remove `fomat` from ReactDOM's props (@davesnx in https://github.com/reasonml/reason-react/pull/929) * Fix typo on `onEncrypted` (@davesnx in https://github.com/reasonml/reason-react/pull/930) diff --git a/docs/adding-data-props.md b/docs/adding-data-props.md index da0fc8fcb..f96ac4132 100644 --- a/docs/adding-data-props.md +++ b/docs/adding-data-props.md @@ -2,21 +2,79 @@ title: Adding data-* attributes --- -Reason doesn't support using props with dashes right now, ie: `data-id` or `data-whatever`. You can overcome this by creating a `Spread` component: +DOM JSX accepts custom data attributes as camelCase props: ```reason -/* Spread.re */ -[@react.component] -let make = (~props, ~children) => React.cloneElement(children, props); +let element =
; ``` -Using Spread: +The rendered element has `data-test-id="item-42"` and `data-state="ready"`. +This works on both HTML and SVG elements. + +## Values + +Data attribute values have type `string`. They can be literals or expressions: + +```reason +let itemId = 42; +let element =
; +``` + +Pass an `option(string)` with `=?` to make an attribute optional. `Some(value)` +sets the attribute, and `None` omits it: ```reason -[@react.component] -let make = () => - - /* This div will now have the `data-cy` attribute in the DOM! */ -
- ; +let render = (state: option(string)) =>
; + +let ready = render(Some("ready")); +let absent = render(None); ``` + +## Attribute names + +Uppercase letters become lowercase, with hyphens at word boundaries. Acronyms +stay together, digits stay attached to the preceding word, and underscores are +preserved: + +| JSX prop | DOM attribute | +| --- | --- | +| `dataTestId` | `data-test-id` | +| `dataURLPath` | `data-url-path` | +| `dataVersion2` | `data-version2` | +| `dataFoo_bar` | `data-foo_bar` | +| `dataFoo_Bar` | `data-foo_bar` | +| `dataFoo__bar` | `data-foo__bar` | +| `data_foo` | `data_foo` | +| `datafoo` | `datafoo` | + +The standard `data` and `datatype` props keep their existing meanings. Other +props beginning with `data` follow the conversion above. Names containing +apostrophes are rejected because they are invalid DOM attribute names. + +Each attribute name can occur only once on an element. Repeating a prop or +using two props that produce the same name is a compile-time error, even when +an optional value is `None`: + +```reason +/* Rejected: both props render as data-url. */ +let element =
; +``` + +`dataFoo` and `data_foo` are distinct: they produce `data-foo` and `data_foo`. + +## Component props + +The name conversion applies to DOM elements. Props on your own components keep +their declared names and types. Convert values when forwarding them to the DOM: + +```reason +module Item = { + [@react.component] + let make = (~dataId: int) =>
; +}; + +let element = ; +``` + +Ordinary DOM props such as `className`, `onClick`, and `ref` retain their usual +type checks when used alongside data attributes. diff --git a/docs/jsx.md b/docs/jsx.md index e562c91fc..69392c905 100644 --- a/docs/jsx.md +++ b/docs/jsx.md @@ -53,6 +53,9 @@ Which compiles to React.createElement('div', {}) ``` +DOM elements also support custom [`data-*` attributes](adding-data-props.md), +written as camelCase props such as `dataTestId`. + ## Capitalized ```reason diff --git a/ppx/dom_props.ml b/ppx/dom_props.ml new file mode 100644 index 000000000..74625d3c5 --- /dev/null +++ b/ppx/dom_props.ml @@ -0,0 +1,295 @@ +open Ppxlib +open Ast_builder.Default + +let attribute ~loc ?(payload = PStr []) name = + attribute ~loc ~name:{ txt = name; loc } ~payload + +let data_attribute name = + (* Keep the standard [data] and [datatype] props on the ordinary DOM path. + Other data-prefixed names follow server-reason-react's conversion. *) + if + String.starts_with ~prefix:"data" name + && name <> "data" && name <> "datatype" + then ( + let len = String.length name in + let is_upper c = c >= 'A' && c <= 'Z' in + let is_lower c = c >= 'a' && c <= 'z' in + let buffer = Buffer.create (len + 4) in + String.iteri + (fun i c -> + if c = '_' then Buffer.add_char buffer '_' + else if is_upper c then ( + let prev = if i > 0 then Some name.[i - 1] else None in + let next_is_lower = i + 1 < len && is_lower name.[i + 1] in + let starts_word = + match prev with + | None | Some '_' -> false + | Some p -> (not (is_upper p)) || next_is_lower + in + if starts_word then Buffer.add_char buffer '-'; + Buffer.add_char buffer (Char.lowercase_ascii c)) + else Buffer.add_char buffer c) + name; + Some (Buffer.contents buffer)) + else None + +(* These are the [mel.as] conventions used by ReactDOM.domProps. Ordinary + React prop names, such as className and onClick, keep their spelling. *) +let js_name name = + match name with + | "as_" | "begin_" | "end_" | "in_" | "open_" | "to_" | "type_" -> + Some (String.sub name 0 (String.length name - 1)) + | _ when String.length name > 4 && String.sub name 0 4 = "aria" -> + Some + ("aria-" + ^ String.lowercase_ascii (String.sub name 4 (String.length name - 4))) + | _ -> None + +let mel_obj_name name = + let rec has_double_underscore i = + i + 1 < String.length name + && ((name.[i] = '_' && name.[i + 1] = '_') || has_double_underscore (i + 1)) + in + (* [mel.obj] strips the last [__] suffix even after [mel.as]. Append a suffix + of our own so underscores in the actual attribute name remain intact. *) + if has_double_underscore 0 then name ^ "__" else name + +let label_name = function + | Labelled name | Optional name -> name + | Nolabel -> "" + +let validate_data_attributes ~tag_name args = + let seen = Hashtbl.create 8 in + List.iter + (fun (label, expression) -> + let jsx_name = label_name label in + Option.iter + (fun name -> + if String.contains name '\'' then + Location.raise_errorf ~loc:expression.pexp_loc + "JSX: %s renders as the invalid DOM attribute name %S" jsx_name + name; + match Hashtbl.find_opt seen name with + | None -> Hashtbl.add seen name jsx_name + | Some first when String.equal first jsx_name -> + Location.raise_errorf ~loc:expression.pexp_loc + "JSX: the prop %s appears more than once on <%s>" jsx_name + tag_name + | Some first -> + Location.raise_errorf ~loc:expression.pexp_loc + "JSX: %s and %s both render as the attribute %s" jsx_name first + name) + (data_attribute jsx_name)) + args + +let ignored_type ~loc typ = + { typ with ptyp_attributes = [ attribute ~loc "mel.ignore" ] } + +(* [mel.obj] requires a literal [unit] type for unlabelled arguments. Use an + ignored labelled argument so the type can be qualified against shadowing. *) +let make_label = function Nolabel -> Labelled "__jsx_unit" | label -> label + +type prop = { + label : arg_label; + variable : string; + typ : core_type; + data_name : string option; + expression : expression; +} + +let make ~loc ~tag_name ~dom_props args = + if + not + (List.exists + (fun (label, _) -> Option.is_some (data_attribute (label_name label))) + args) + then dom_props args + else + let () = validate_data_attributes ~tag_name args in + let ghost_loc = { loc with loc_ghost = true } in + let synthetic_loc = Location.none in + let stdlib_type name = + ptyp_constr ~loc:ghost_loc + { txt = Ldot (Ldot (Lident "Stdlib", name), "t"); loc = ghost_loc } + [] + in + let unit_type = stdlib_type "Unit" in + let string_type = stdlib_type "String" in + let props_type = + ptyp_constr ~loc:ghost_loc + { txt = Ldot (Lident "ReactDOM", "domProps"); loc = ghost_loc } + [] + in + let props = + List.map + (fun (label, expression) -> + let variable = gen_symbol ~prefix:"prop" () in + let data_name = data_attribute (label_name label) in + let typ = + match (label, data_name) with + | Nolabel, _ -> unit_type + | _, Some _ -> string_type + | _, None -> ptyp_var ~loc:synthetic_loc variable + in + { label; variable; typ; data_name; expression }) + args + in + let ordinary_props = + List.filter (fun prop -> prop.data_name = None) props + in + let arrow { label; typ; _ } result = + ptyp_arrow ~loc:ghost_loc label typ result + in + (* The shared type variables connect each supplied prop to the corresponding + argument of ReactDOM.domProps. Melange erases this pure callback after + OCaml has checked both its labels and its types. *) + let check_type = + ignored_type ~loc:ghost_loc + (List.fold_right arrow ordinary_props props_type) + in + let editor_copy { pexp_desc; _ } = + (* Reason represents completion holes and partially typed props as + identifiers. Copy only those small expressions: copying arbitrary + values would duplicate nested JSX expansions and their typing work. *) + match pexp_desc with + | Pexp_ident _ -> true + | _ -> false + in + let editor_attributes = + (* Report diagnostics on the original expression only. The copy exists + solely to give Merlin the ordinary DOM constructor's context. *) + List.map + (fun (name, flags) -> + attribute ~loc:ghost_loc name + ~payload: + (PStr + [ pstr_eval ~loc:ghost_loc (estring ~loc:ghost_loc flags) [] ])) + [ ("alert", "-all"); ("warning", "-a") ] + in + let check_args = + List.map + (fun { label; variable; expression; _ } -> + (label, evar ~loc:expression.pexp_loc variable)) + ordinary_props + in + let hidden_check = dom_props check_args in + let hidden_check = + { + hidden_check with + pexp_attributes = [ attribute ~loc:ghost_loc "merlin.hide" ]; + } + in + let editor_args = + List.map + (fun { label; variable; expression; _ } -> + let expr = + if editor_copy expression then + { + expression with + pexp_attributes = + attribute ~loc:expression.pexp_loc "merlin.focus" + :: expression.pexp_attributes + @ editor_attributes; + } + else + let expr = evar ~loc:expression.pexp_loc variable in + { + expr with + pexp_attributes = [ attribute ~loc:synthetic_loc "merlin.hide" ]; + } + in + (label, expr)) + ordinary_props + in + let check_body = + (* Infer the constructor's argument types first, then give Merlin a DOM + application containing the original identifiers. Other values remain + visible in the constructor, with the inferred types as their context. *) + pexp_let ~loc:ghost_loc Nonrecursive + [ + value_binding ~loc:synthetic_loc + ~pat:(ppat_any ~loc:synthetic_loc) + ~expr:hidden_check; + ] + (dom_props editor_args) + in + let check = + List.fold_right + (fun { label; variable; _ } body -> + pexp_fun ~loc:ghost_loc label None + (pvar ~loc:synthetic_loc variable) + body) + ordinary_props check_body + in + let make_type = + List.fold_right + (fun { label; typ; data_name; _ } result -> + let name = + match data_name with + | Some _ as name -> name + | None -> js_name (label_name label) + in + let attributes = + match (label, name) with + | Nolabel, _ -> [ attribute ~loc:ghost_loc "mel.ignore" ] + | _, None -> [] + | _, Some name -> + [ + attribute ~loc:ghost_loc "mel.as" + ~payload: + (PStr + [ + pstr_eval ~loc:ghost_loc + (estring ~loc:ghost_loc (mel_obj_name name)) + []; + ]); + ] + in + ptyp_arrow ~loc:ghost_loc (make_label label) + { typ with ptyp_attributes = attributes } + result) + props props_type + in + let make_type = + ptyp_arrow ~loc:ghost_loc (Labelled "check") check_type make_type + in + let make = + value_description ~loc:ghost_loc + ~name:{ txt = "make"; loc = ghost_loc } + ~type_:make_type ~prim:[ "" ] + in + let make = + { make with pval_attributes = [ attribute ~loc:ghost_loc "mel.obj" ] } + in + let module_name = gen_symbol ~prefix:"Jsx_props" () in + let module_ = + pmod_structure ~loc:synthetic_loc + [ pstr_primitive ~loc:synthetic_loc make ] + in + let call = + pexp_apply ~loc + (pexp_ident ~loc:synthetic_loc + { txt = Ldot (Lident module_name, "make"); loc = synthetic_loc }) + ((Labelled "check", check) + :: List.map + (fun (label, expression) -> + let expression = + if + Option.is_none (data_attribute (label_name label)) + && (editor_copy expression + || (label = Nolabel && expression.pexp_loc.loc_ghost)) + then + { + expression with + pexp_attributes = + attribute ~loc:expression.pexp_loc "merlin.hide" + :: expression.pexp_attributes; + } + else expression + in + (make_label label, expression)) + args) + in + pexp_letmodule ~loc:ghost_loc + { txt = Some module_name; loc = ghost_loc } + module_ call diff --git a/ppx/reason_react_ppx.ml b/ppx/reason_react_ppx.ml index 1f5f4d24e..ef25c3c83 100644 --- a/ppx/reason_react_ppx.ml +++ b/ppx/reason_react_ppx.ml @@ -526,11 +526,16 @@ let jsxMapper = reactJsxExprAndChildren ~loc:parentExpLoc ~ctxt ~keyProps mapper children in let propsArg = - (match childrenProp with - | Some childrenProp -> (labelled "children", childrenProp) :: otherProps - | None -> otherProps) - |> List.map (fun (label, expression) -> - (label, mapper#expression ctxt expression)) + let otherProps = + List.map + (fun (label, expression) -> + (label, mapper#expression ctxt expression)) + otherProps + in + (* [reactJsxExprAndChildren] has already transformed the children. *) + match childrenProp with + | Some childrenProp -> (labelled "children", childrenProp) :: otherProps + | None -> otherProps in let isCap str = match String.length str with @@ -610,17 +615,25 @@ let jsxMapper = children in let props = - (match childrenProp with - | Some childrenProp -> - (labelled "children", childrenProp) :: nonChildrenProps - | None -> nonChildrenProps) - |> List.map (fun (label, expression) -> - (label, mapper#expression ctxt expression)) + let nonChildrenProps = + List.map + (fun (label, expression) -> + (label, mapper#expression ctxt expression)) + nonChildrenProps + in + (* Avoid walking the already transformed children at every parent. *) + match childrenProp with + | Some childrenProp -> + (labelled "children", childrenProp) :: nonChildrenProps + | None -> nonChildrenProps in let component = (nolabel, componentNameExpr) and props = ( nolabel, - Binding.ReactDOM.domProps ~applyLoc:parentExpLoc ~loc:callerLoc props ) + Dom_props.make ~loc:parentExpLoc ~tag_name:id + ~dom_props: + (Binding.ReactDOM.domProps ~applyLoc:parentExpLoc ~loc:callerLoc) + props ) in let loc = parentExpLoc in let gloc = { loc with loc_ghost = true } in diff --git a/ppx/test/data-attribute-collisions.t/input.re b/ppx/test/data-attribute-collisions.t/input.re index 6dc684a4b..69fc25d22 100644 --- a/ppx/test/data-attribute-collisions.t/input.re +++ b/ppx/test/data-attribute-collisions.t/input.re @@ -1,5 +1,4 @@ -let aliases =
; -let repeated =
; +let distinct =
; let optional = (first, second) =>
; let optionalFirst = first =>
; @@ -9,7 +8,7 @@ let effects =
; let serverNames = @@ -20,10 +19,11 @@ let serverNames = dataFoo_bar="single" dataURL="acronym" dataURLPath="acronym then word" - dataFoo_Bar="underscore then uppercase" dataVersion2="digit" dataVersion20="digits" data2="leading digit" data_foo="leading underscore" datafoo="lowercase" />; + +let underscoreThenUppercase =
; diff --git a/ppx/test/data-attribute-collisions.t/run.t b/ppx/test/data-attribute-collisions.t/run.t index 77406201a..55b7db152 100644 --- a/ppx/test/data-attribute-collisions.t/run.t +++ b/ppx/test/data-attribute-collisions.t/run.t @@ -1,38 +1,179 @@ -Snapshot DOM JSX with repeated data props and names that normalize to the same -attribute in server-reason-react#412. Run only the JSX PPX so this baseline can -capture the expansion before data attribute type-checking is supported. +Snapshot distinct data names and reject repeated or aliased names, following +server-reason-react#420. This exercises the JSX PPX before type-checking. $ ../ppx.sh --output ml input.re - let aliases = + let distinct = ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) ~dataFoo:"first" ~data_foo:"second" - ()) - let repeated = - ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) ~dataFoo:"first" ~dataFoo:"second" - ()) + (let module Jsx_props__004_ = + struct + external make : + check:((Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) -> + dataFoo:((Stdlib.String.t)[@mel.as "data-foo"]) -> + data_foo:((Stdlib.String.t)[@mel.as "data_foo"]) -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__004_.make + ~check:(fun prop__003_ -> + let _ = ((((ReactDOM.domProps)[@merlin.hide ]) prop__003_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) ((prop__003_) + [@merlin.hide ])) ~dataFoo:"first" ~data_foo:"second" + ~__jsx_unit:()) let optional first = fun second -> ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) ?dataFoo:first ?data_foo:second - ()) + (let module Jsx_props__008_ = + struct + external make : + check:((Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) -> + ?dataFoo:((Stdlib.String.t)[@mel.as "data-foo"]) -> + ?data_foo:((Stdlib.String.t)[@mel.as "data_foo"]) -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__008_.make + ~check:(fun prop__007_ -> + let _ = + ((((ReactDOM.domProps)[@merlin.hide ]) prop__007_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) ((prop__007_) + [@merlin.hide ])) ?dataFoo:first ?data_foo:second + ~__jsx_unit:()) let optionalFirst first = ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) ?dataFoo:first ~data_foo:"fallback" - ()) + (let module Jsx_props__012_ = + struct + external make : + check:((Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) -> + ?dataFoo:((Stdlib.String.t)[@mel.as "data-foo"]) -> + data_foo:((Stdlib.String.t)[@mel.as "data_foo"]) -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__012_.make + ~check:(fun prop__011_ -> + let _ = ((((ReactDOM.domProps)[@merlin.hide ]) prop__011_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) ((prop__011_) + [@merlin.hide ])) ?dataFoo:first ~data_foo:"fallback" + ~__jsx_unit:()) let requiredFirst second = ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) ~dataFoo:"first" ?data_foo:second - ()) + (let module Jsx_props__016_ = + struct + external make : + check:((Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) -> + dataFoo:((Stdlib.String.t)[@mel.as "data-foo"]) -> + ?data_foo:((Stdlib.String.t)[@mel.as "data_foo"]) -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__016_.make + ~check:(fun prop__015_ -> + let _ = ((((ReactDOM.domProps)[@merlin.hide ]) prop__015_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) ((prop__015_) + [@merlin.hide ])) ~dataFoo:"first" ?data_foo:second + ~__jsx_unit:()) let effects = ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) ~className:(next "class") - ~dataURL:(next "first") ~dataUrl:(next "second") ()) + (let module Jsx_props__021_ = + struct + external make : + check:((className:'prop__017_ -> + Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) + -> + className:'prop__017_ -> + dataURL:((Stdlib.String.t)[@mel.as "data-url"]) -> + data_URL:((Stdlib.String.t)[@mel.as "data_url"]) -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__021_.make + ~check:(fun ~className:prop__017_ prop__020_ -> + let _ = + ((((ReactDOM.domProps)[@merlin.hide ]) + ~className:prop__017_ prop__020_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) + ~className:((prop__017_)[@merlin.hide ]) ((prop__020_) + [@merlin.hide ])) ~className:(next "class") + ~dataURL:(next "first") ~data_URL:(next "second") ~__jsx_unit:()) let serverNames = ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) ~dataFoo:"plain" - ~dataFoo__bar:"double" ~dataFoo___:"trailing" ~dataFoo_bar:"single" - ~dataURL:"acronym" ~dataURLPath:"acronym then word" - ~dataFoo_Bar:"underscore then uppercase" ~dataVersion2:"digit" - ~dataVersion20:"digits" ~data2:"leading digit" - ~data_foo:"leading underscore" ~datafoo:"lowercase" ()) + (let module Jsx_props__034_ = + struct + external make : + check:((Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) -> + dataFoo:((Stdlib.String.t)[@mel.as "data-foo"]) -> + dataFoo__bar:((Stdlib.String.t)[@mel.as "data-foo__bar__"]) -> + dataFoo___:((Stdlib.String.t)[@mel.as "data-foo_____"]) -> + dataFoo_bar:((Stdlib.String.t)[@mel.as "data-foo_bar"]) -> + dataURL:((Stdlib.String.t)[@mel.as "data-url"]) -> + dataURLPath:((Stdlib.String.t)[@mel.as + "data-url-path"]) + -> + dataVersion2:((Stdlib.String.t)[@mel.as + "data-version2"]) + -> + dataVersion20:((Stdlib.String.t)[@mel.as + "data-version20"]) + -> + data2:((Stdlib.String.t)[@mel.as "data2"]) -> + data_foo:((Stdlib.String.t)[@mel.as + "data_foo"]) + -> + datafoo:((Stdlib.String.t)[@mel.as + "datafoo"]) + -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) + -> ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__034_.make + ~check:(fun prop__033_ -> + let _ = ((((ReactDOM.domProps)[@merlin.hide ]) prop__033_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) ((prop__033_) + [@merlin.hide ])) ~dataFoo:"plain" + ~dataFoo__bar:"double" ~dataFoo___:"trailing" ~dataFoo_bar:"single" + ~dataURL:"acronym" ~dataURLPath:"acronym then word" + ~dataVersion2:"digit" ~dataVersion20:"digits" ~data2:"leading digit" + ~data_foo:"leading underscore" ~datafoo:"lowercase" ~__jsx_unit:()) + let underscoreThenUppercase = + ReactDOM.jsx "div" + (let module Jsx_props__037_ = + struct + external make : + check:((Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) -> + dataFoo_Bar:((Stdlib.String.t)[@mel.as "data-foo_bar"]) -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__037_.make + ~check:(fun prop__036_ -> + let _ = ((((ReactDOM.domProps)[@merlin.hide ]) prop__036_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) ((prop__036_) + [@merlin.hide ])) + ~dataFoo_Bar:"underscore then uppercase" ~__jsx_unit:()) + + $ cat > repeated.re < let element =
; + > EOF + $ ../ppx.sh --output ml repeated.re + File "output.ml", line 1, characters 42-45: + 1 | let element = ((div ~dataFoo:"a" ~dataFoo:"b" ~children:[] ())[@JSX ]) + ^^^ + Error: JSX: the prop dataFoo appears more than once on
+ [1] + + $ cat > aliases.re < let element =
; + > EOF + $ ../ppx.sh --output ml aliases.re + File "output.ml", line 1, characters 42-46: + 1 | let element = ((div ~dataURL:"a" ?dataUrl:None ~children:[] ())[@JSX ]) + ^^^^ + Error: JSX: dataUrl and dataURL both render as the attribute data-url + [1] diff --git a/ppx/test/data-attributes.t/run.t b/ppx/test/data-attributes.t/run.t index 4e8ef6687..1c4b5bf1f 100644 --- a/ppx/test/data-attributes.t/run.t +++ b/ppx/test/data-attributes.t/run.t @@ -10,26 +10,149 @@ required and optional data attributes, renamed props, expressions, and nested JS (((ReactDOM.domProps)[@merlin.hide ]) ~className:"button" ()) let required = ReactDOM.jsx "button" - (((ReactDOM.domProps)[@merlin.hide ]) ~className ~dataTestId - ~onClick:(fun event -> React.Event.Mouse.preventDefault event) ()) + (let module Jsx_props__005_ = + struct + external make : + check:((className:'prop__001_ -> + onClick:'prop__003_ -> + Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) + -> + className:'prop__001_ -> + dataTestId:((Stdlib.String.t)[@mel.as "data-test-id"]) -> + onClick:'prop__003_ -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__005_.make + ~check:(fun ~className:prop__001_ ~onClick:prop__003_ prop__004_ -> + let _ = + ((((ReactDOM.domProps)[@merlin.hide ]) + ~className:prop__001_ ~onClick:prop__003_ prop__004_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) + ~className:((className) + [@merlin.focus ][@alert "-all"][@warning "-a"]) + ~onClick:((prop__003_)[@merlin.hide ]) ((prop__004_) + [@merlin.hide ])) ~className:((className) + [@merlin.hide ]) ~dataTestId + ~onClick:(fun event -> React.Event.Mouse.preventDefault event) + ~__jsx_unit:()) let optional ?className = fun ?dataFoo -> fun () -> ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) ?className ?dataFoo ()) + (let module Jsx_props__009_ = + struct + external make : + check:((?className:'prop__006_ -> + Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) + -> + ?className:'prop__006_ -> + ?dataFoo:((Stdlib.String.t)[@mel.as "data-foo"]) -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__009_.make + ~check:(fun ?className:prop__006_ prop__008_ -> + let _ = + ((((ReactDOM.domProps)[@merlin.hide ]) + ?className:prop__006_ prop__008_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) + ?className:((className) + [@merlin.focus ][@alert "-all"][@warning "-a"]) + ((prop__008_)[@merlin.hide ])) + ?className:((className)[@merlin.hide ]) ?dataFoo ~__jsx_unit:()) let renamed = ReactDOM.jsx "input" - (((ReactDOM.domProps)[@merlin.hide ]) ~type_:"text" ~ariaLabel:"name" - ~dataFoo__bar:"value" ()) + (let module Jsx_props__014_ = + struct + external make : + check:((type_:'prop__010_ -> + ariaLabel:'prop__011_ -> + Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) + -> + type_:(('prop__010_)[@mel.as "type"]) -> + ariaLabel:(('prop__011_)[@mel.as "aria-label"]) -> + dataFoo__bar:((Stdlib.String.t)[@mel.as "data-foo__bar__"]) + -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__014_.make + ~check:(fun ~type_:prop__010_ ~ariaLabel:prop__011_ prop__013_ -> + let _ = + ((((ReactDOM.domProps)[@merlin.hide ]) ~type_:prop__010_ + ~ariaLabel:prop__011_ prop__013_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) ~type_:((prop__010_) + [@merlin.hide ]) ~ariaLabel:((prop__011_) + [@merlin.hide ]) ((prop__013_)[@merlin.hide ])) + ~type_:"text" ~ariaLabel:"name" ~dataFoo__bar:"value" ~__jsx_unit:()) let expressions = ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) ~className:(next "class") - ~dataFoo:(next "data") ()) + (let module Jsx_props__018_ = + struct + external make : + check:((className:'prop__015_ -> + Stdlib.Unit.t -> ReactDOM.domProps)[@mel.ignore ]) + -> + className:'prop__015_ -> + dataFoo:((Stdlib.String.t)[@mel.as "data-foo"]) -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__018_.make + ~check:(fun ~className:prop__015_ prop__017_ -> + let _ = + ((((ReactDOM.domProps)[@merlin.hide ]) + ~className:prop__015_ prop__017_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) + ~className:((prop__015_)[@merlin.hide ]) ((prop__017_) + [@merlin.hide ])) ~className:(next "class") + ~dataFoo:(next "data") ~__jsx_unit:()) let nested = ReactDOM.jsx "div" - (((ReactDOM.domProps)[@merlin.hide ]) - ~children:(ReactDOM.jsx "span" - (((ReactDOM.domProps)[@merlin.hide ]) ~dataBar:"inner" ())) - ~dataFoo:"outer" ()) + (let module Jsx_props__025_ = + struct + external make : + check:((children:'prop__022_ -> Stdlib.Unit.t -> ReactDOM.domProps) + [@mel.ignore ]) -> + children:'prop__022_ -> + dataFoo:((Stdlib.String.t)[@mel.as "data-foo"]) -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) -> + ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__025_.make + ~check:(fun ~children:prop__022_ prop__024_ -> + let _ = + ((((ReactDOM.domProps)[@merlin.hide ]) + ~children:prop__022_ prop__024_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) + ~children:((prop__022_)[@merlin.hide ]) ((prop__024_) + [@merlin.hide ])) + ~children:(ReactDOM.jsx "span" + (let module Jsx_props__021_ = + struct + external make : + check:((Stdlib.Unit.t -> ReactDOM.domProps) + [@mel.ignore ]) -> + dataBar:((Stdlib.String.t)[@mel.as "data-bar"]) + -> + __jsx_unit:((Stdlib.Unit.t)[@mel.ignore ]) + -> ReactDOM.domProps = ""[@@mel.obj ] + end in + Jsx_props__021_.make + ~check:(fun prop__020_ -> + let _ = + ((((ReactDOM.domProps)[@merlin.hide ]) + prop__020_) + [@merlin.hide ]) in + ((ReactDOM.domProps)[@merlin.hide ]) + ((prop__020_)[@merlin.hide ])) + ~dataBar:"inner" ~__jsx_unit:())) ~dataFoo:"outer" + ~__jsx_unit:()) let component = React.jsx Widget.make (Widget.makeProps ~dataFoo:"component" ()) diff --git a/test/ReactDOMDataAttributes__test.re b/test/ReactDOMDataAttributes__test.re index 961a2bb1a..e2cf716f3 100644 --- a/test/ReactDOMDataAttributes__test.re +++ b/test/ReactDOMDataAttributes__test.re @@ -5,21 +5,13 @@ open Jest.Expect; external getAttribute: (Dom.element, string) => Js.nullable(string) = "getAttribute"; -/* Exercise React's data attribute behavior through the existing cloning API. - The JSX implementation can use the same assertions once it accepts data props. */ describe("ReactDOM data attributes", () => { - test("renders data attributes alongside ordinary props", () => { + test("renders arbitrary camelCase names alongside ordinary props", () => { let html = ReactDOMServer.renderToStaticMarkup( - React.cloneElement( -
- {React.cloneElement(, { "data-foo-bar": "second" })} -
, - { - "data-test-id": "first", - "data-version2": "v2", - }, - ), +
+ +
, ); expect(html) ->toBe( @@ -29,25 +21,14 @@ describe("ReactDOM data attributes", () => { test("omits absent optional attributes", () => { let render = dataFoo => - ReactDOMServer.renderToStaticMarkup( - React.cloneElement( -
, - { "data-foo": Js.Undefined.fromOption(dataFoo) }, - ), - ); + ReactDOMServer.renderToStaticMarkup(
); expect(render(None))->toBe("
"); expect(render(Some("value")))->toBe("
"); }); test("updates and removes data attributes on the same DOM node", () => { let element = (value, state) => - React.cloneElement( -