{(child(),3)})}/>;}",
+ 6
+)]
+#[case("function f(){return <>{(first(),last())};}", 2)]
+#[case("function f(){return <><>{(first(),last())};}", 2)]
+#[case("async function f(p){return
{(first(),await p)}
;}", 2)]
+#[case("function* f(){return
{(first(),yield 1)}
;}", 2)]
+fn grouping_changes_only_the_missing_parentheses(#[case] source: &str, #[case] added: usize) {
+ let arena = Allocator::default();
+ let parsed = Parser::new(&arena, source, SourceType::tsx()).parse();
+ assert!(parsed.diagnostics.is_empty());
+ let mut result = Codegen::new().build(&parsed.program);
+ let before = result.code.clone();
+ parenthesize(&mut result, SourceType::tsx()).unwrap_or_else(|error| panic!("{error:?}"));
+ assert_eq!(result.code.len(), before.len() + added);
+ assert!(
+ Parser::new(&arena, &result.code, SourceType::tsx())
+ .parse()
+ .diagnostics
+ .is_empty()
+ );
+ // Parsing the result again and printing it produces the same ungrouped
+ // Oxc output. Thus grouping adds no other AST operation, binding or scope.
+ let grouped = Parser::new(&arena, &result.code, SourceType::tsx()).parse();
+ assert_eq!(Codegen::new().build(&grouped.program).code, before);
+}
+
+#[test]
+fn valid_output_is_byte_and_map_identical() {
+ let source = "const value=(first(),last());";
+ let arena = Allocator::default();
+ let parsed = Parser::new(&arena, source, SourceType::tsx()).parse();
+ let mut result = Codegen::new()
+ .with_options(CodegenOptions {
+ source_map_path: Some("input.tsx".into()),
+ ..CodegenOptions::default()
+ })
+ .build(&parsed.program);
+ let before = result.code.clone();
+ let map = result
+ .map
+ .as_ref()
+ .unwrap_or_else(|| panic!("expected generated source map"))
+ .to_json_string();
+ parenthesize(&mut result, SourceType::tsx()).unwrap_or_else(|error| panic!("{error:?}"));
+ assert_eq!(result.code, before);
+ assert_eq!(
+ result
+ .map
+ .as_ref()
+ .unwrap_or_else(|| panic!("expected generated source map"))
+ .to_json_string(),
+ map
+ );
+}
+
+#[test]
+fn other_generated_errors_are_not_recovered() {
+ let arena = Allocator::default();
+ let parsed = Parser::new(&arena, "const ok=1;", SourceType::tsx()).parse();
+ let mut result = Codegen::new().build(&parsed.program);
+ result.code = "const = ;".into();
+ let error = match parenthesize(&mut result, SourceType::tsx()) {
+ Err(error) => error.to_string(),
+ Ok(()) => panic!("invalid generated JSX must remain an error"),
+ };
+ assert!(error.starts_with("Cannot emit JSX:"), "{error}");
+ assert_eq!(result.code, "const = ;");
+ assert!(validate("
{first(),last()}
", SourceType::tsx()).is_err());
+}
+
+#[test]
+fn generated_map_column_overflow_is_reported() {
+ let parts = oxc_sourcemap::SourceMapParts {
+ tokens: vec![oxc_sourcemap::Token::new(0, u32::MAX, 0, 0, None, None)].into_boxed_slice(),
+ ..oxc_sourcemap::SourceMapParts::default()
+ };
+ let error = match crate::source_map::shift_generated(SourceMap::from_parts(parts), "a", &[0]) {
+ Err(error) => error.to_string(),
+ Ok(_) => panic!("generated source map column overflow must remain an error"),
+ };
+ assert_eq!(error, "Generated source map column overflow");
+}
+
+#[test]
+#[serial_test::serial]
+fn original_invalid_jsx_remains_a_located_source_error() {
+ let error = match crate::extract(
+ "original.tsx",
+ "import {Box} from '@devup-ui/react';const value=
;",
+ crate::ExtractOption::default(),
+ ) {
+ Err(error) => error.to_string(),
+ Ok(_) => panic!("original invalid JSX must remain a located error"),
+ };
+ assert!(error.starts_with("original.tsx:1:"), "{error}");
+ assert!(error.contains("comma operator"), "{error}");
+}
+
+#[test]
+#[serial_test::serial]
+fn compiled_elements_use_the_rare_emission_path() {
+ let source = "import {Box} from '@devup-ui/react';function f(){return {(before(),child())};}";
+ let output = crate::extract("compiled.tsx", source, crate::ExtractOption::default())
+ .unwrap_or_else(|error| panic!("{error:?}"));
+ let arena = Allocator::default();
+ assert!(
+ Parser::new(&arena, &output.code, SourceType::tsx())
+ .parse()
+ .diagnostics
+ .is_empty(),
+ "{}",
+ output.code
+ );
+ assert!(
+ output.code.contains("(before(), child())"),
+ "{}",
+ output.code
+ );
+}
+
+#[test]
+fn unicode_nested_jsx_keeps_source_map_metadata_and_token_origins() {
+ let source = "const label='🦀';\r\nfunction f(){return é🦀\r\n\u{2028}\u{2029}{(child(),label)})}/>;}";
+ let arena = Allocator::default();
+ let parsed = Parser::new(&arena, source, SourceType::tsx()).parse();
+ assert!(parsed.diagnostics.is_empty());
+ let mut result = Codegen::new()
+ .with_options(CodegenOptions {
+ source_map_path: Some("input.tsx".into()),
+ ..CodegenOptions::default()
+ })
+ .build(&parsed.program);
+ let old_code = result.code.clone();
+ assert!(
+ old_code.contains("\r\n") && old_code.contains('\u{2028}') && old_code.contains('\u{2029}')
+ );
+ let mut before = result
+ .map
+ .take()
+ .unwrap_or_else(|| panic!("expected generated source map"))
+ .into_parts();
+ before.file = Some(Cow::Borrowed("output.js"));
+ before.source_root = Some(Cow::Borrowed("/root"));
+ before.ignore_list = Some(vec![0]);
+ before.debug_id = Some(Cow::Borrowed("emission-test"));
+ let middle = before.tokens.len() / 2;
+ let previous = before.tokens[middle - 1];
+ let previous_name = before.tokens[..middle]
+ .iter()
+ .rev()
+ .find_map(oxc_sourcemap::Token::get_name_id)
+ .unwrap_or(0);
+ before.token_chunks = Some(vec![
+ TokenChunk::new(
+ 0,
+ u32::try_from(middle).unwrap_or_else(|error| panic!("{error:?}")),
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ ),
+ TokenChunk::new(
+ u32::try_from(middle).unwrap_or_else(|error| panic!("{error:?}")),
+ u32::try_from(before.tokens.len()).unwrap_or_else(|error| panic!("{error:?}")),
+ previous.get_dst_line(),
+ previous.get_dst_col(),
+ previous.get_src_line(),
+ previous.get_src_col(),
+ previous_name,
+ previous.get_source_id().unwrap_or(0),
+ ),
+ ]);
+ result.map = Some(SourceMap::from_parts(before.clone()));
+ parenthesize(&mut result, SourceType::tsx()).unwrap_or_else(|error| panic!("{error:?}"));
+ assert_eq!(result.code.len(), old_code.len() + 6);
+ let after = result
+ .map
+ .as_ref()
+ .unwrap_or_else(|| panic!("expected generated source map"))
+ .clone()
+ .into_parts();
+ assert_eq!(after.file, before.file);
+ assert_eq!(after.names, before.names);
+ assert_eq!(after.source_root, before.source_root);
+ assert_eq!(after.sources, before.sources);
+ assert_eq!(after.source_contents, before.source_contents);
+ assert_eq!(after.ignore_list, before.ignore_list);
+ assert_eq!(after.debug_id, before.debug_id);
+ assert_eq!(after.tokens.len(), before.tokens.len());
+ let old_lines = crate::source_map::Lines::new(&old_code);
+ let new_lines = crate::source_map::Lines::new(&result.code);
+ for (old, new) in before.tokens.iter().zip(after.tokens.iter()) {
+ assert_eq!(
+ (
+ old.get_src_line(),
+ old.get_src_col(),
+ old.get_source_id(),
+ old.get_name_id()
+ ),
+ (
+ new.get_src_line(),
+ new.get_src_col(),
+ new.get_source_id(),
+ new.get_name_id()
+ )
+ );
+ assert_eq!(old.get_dst_line(), new.get_dst_line());
+ let old_offset = old_lines.offset(old.get_dst_line(), old.get_dst_col());
+ let new_offset = new_lines.offset(new.get_dst_line(), new.get_dst_col());
+ assert_eq!(
+ old_code[old_offset..].chars().next(),
+ result.code[new_offset..].chars().next()
+ );
+ }
+ let mut expected_chunks = before
+ .token_chunks
+ .unwrap_or_else(|| panic!("expected original token chunks"));
+ for chunk in &mut expected_chunks {
+ if let Some((_, new)) = before
+ .tokens
+ .iter()
+ .zip(after.tokens.iter())
+ .find(|(old, _)| {
+ old.get_dst_line() == chunk.prev_dst_line && old.get_dst_col() == chunk.prev_dst_col
+ })
+ {
+ chunk.prev_dst_col = new.get_dst_col();
+ }
+ }
+ assert_eq!(
+ after
+ .token_chunks
+ .as_ref()
+ .unwrap_or_else(|| panic!("expected emitted token chunks")),
+ &expected_chunks
+ );
+ let encoded = result
+ .map
+ .as_ref()
+ .unwrap_or_else(|| panic!("expected generated source map"))
+ .to_json_string();
+ let decoded = SourceMap::from_json_string(&encoded).unwrap_or_else(|error| panic!("{error:?}"));
+ assert_eq!(
+ decoded.get_tokens().collect::
>(),
+ after.tokens.to_vec()
+ );
+}
+
+#[rstest]
+#[case("<>{(first(),last())}")]
+#[case("<><>{(first(),last())}")]
+#[serial_test::serial]
+fn compiled_siblings_detect_fragment_sequences(#[case] fragment: &str) {
+ let source = format!(
+ "import {{Box}} from '@devup-ui/react';function f(){{return [,{fragment}];}}"
+ );
+ let output = crate::extract("fragment.tsx", &source, crate::ExtractOption::default())
+ .unwrap_or_else(|error| panic!("{error:?}"));
+ let arena = Allocator::default();
+ assert!(
+ Parser::new(&arena, &output.code, SourceType::tsx())
+ .parse()
+ .diagnostics
+ .is_empty(),
+ "{}",
+ output.code
+ );
+ assert!(output.code.contains("(first(), last())"), "{}", output.code);
+}
+
+#[rstest]
+#[case("input.cjs", "return {(first(),last())}
;", false)]
+#[case("input.js", "const value={(first(),last())}
;", false)]
+#[case(
+ "input.mjs",
+ "export const value={(first(),last())}
;",
+ false
+)]
+#[case(
+ "input.cts",
+ "const count:number=1;const value={(first(),count)}
;",
+ true
+)]
+#[case(
+ "input.cjs",
+ "import x from 'x';console.log(new.target);return {(first(),last())}
;export {x};",
+ false
+)]
+fn emission_preserves_physical_goal_and_generated_jsx(
+ #[case] filename: &str,
+ #[case] source: &str,
+ #[case] typescript: bool,
+) {
+ let source_type = crate::parsing::source_type(filename)
+ .unwrap_or_else(|error| panic!("{error:?}"))
+ .with_jsx(true);
+ assert_eq!(source_type.is_typescript(), typescript);
+ let arena = Allocator::default();
+ let parsed = Parser::new(&arena, source, source_type).parse();
+ assert!(
+ !goal_policy::has_diagnostics(&parsed),
+ "{:?}",
+ parsed.diagnostics
+ );
+ let mut result = Codegen::new().build(&parsed.program);
+ let before = result.code.clone();
+ parenthesize(&mut result, source_type).unwrap_or_else(|error| panic!("{error:?}"));
+ assert_eq!(result.code.len(), before.len() + 2);
+ validate(&result.code, source_type).unwrap_or_else(|error| panic!("{error:?}"));
+ let grouped = Parser::new(&arena, &result.code, source_type).parse();
+ assert_eq!(
+ grouped.program.source_type.is_commonjs(),
+ source_type.is_commonjs()
+ );
+ assert_eq!(Codegen::new().build(&grouped.program).code, before);
+}
+
+#[rstest]
+#[case("input.js", "const value:number=1;")]
+#[case("input.mjs", "return {(first(),last())}
;")]
+#[case("input.cjs", "const value=import.meta;")]
+#[case("input.cjs", "await pending;")]
+fn unrelated_dialect_errors_remain_errors(#[case] filename: &str, #[case] source: &str) {
+ let source_type = crate::parsing::source_type(filename)
+ .unwrap_or_else(|error| panic!("{error:?}"))
+ .with_jsx(true);
+ assert!(validate(source, source_type).is_err());
+}
+
+#[test]
+fn recoverable_non_sequence_emission_error_preserves_code_and_map() {
+ let arena = Allocator::default();
+ let parsed = Parser::new(&arena, "const original=1;", SourceType::tsx()).parse();
+ let mut result = Codegen::new()
+ .with_options(CodegenOptions {
+ source_map_path: Some("original.tsx".into()),
+ ..CodegenOptions::default()
+ })
+ .build(&parsed.program);
+ result.code = "const invalid=/[z-a]/;".into();
+ let checked = Parser::new(&arena, &result.code, SourceType::tsx())
+ .with_options(ParseOptions {
+ parse_regular_expression: true,
+ ..ParseOptions::default()
+ })
+ .parse();
+ assert!(
+ !checked.fatal_error,
+ "fixture must exercise a recoverable diagnostic"
+ );
+ assert_eq!(checked.diagnostics.len(), 1);
+ assert_eq!(
+ checked.diagnostics[0].to_string(),
+ "Invalid regular expression: Character class atom range out of order"
+ );
+ assert_ne!(checked.diagnostics[0].code.number.as_deref(), Some("18007"));
+ let before = result.code.clone();
+ let before_map = result
+ .map
+ .as_ref()
+ .map(oxc_sourcemap::SourceMap::to_json_string);
+ let Err(error) = parenthesize(&mut result, SourceType::tsx()) else {
+ panic!("only missing JSX sequence parentheses can be repaired")
+ };
+ assert_eq!(
+ error.to_string(),
+ "Cannot emit JSX: Invalid regular expression: Character class atom range out of order"
+ );
+ assert_eq!(result.code, before);
+ assert_eq!(
+ result
+ .map
+ .as_ref()
+ .map(oxc_sourcemap::SourceMap::to_json_string),
+ before_map
+ );
+}
diff --git a/libs/extractor/src/jsx_semantics_tests.rs b/libs/extractor/src/jsx_semantics_tests.rs
new file mode 100644
index 000000000..1ed3250c1
--- /dev/null
+++ b/libs/extractor/src/jsx_semantics_tests.rs
@@ -0,0 +1,111 @@
+use super::*;
+use crate::extract_style::style_property::StyleProperty;
+use css::class_map::reset_class_map;
+use css::file_map::reset_file_map;
+
+mod binding_edges;
+mod boundary_classes;
+mod boundary_selection;
+mod call_diagnostics;
+mod call_spread_attachment;
+mod calls;
+mod capture_edges;
+mod capture_elision;
+mod capture_preservation;
+mod create_element;
+mod create_element_attachment;
+mod css_prop;
+mod errors;
+mod evaluation_edges;
+mod factory_order;
+mod forwarded;
+mod gate_edges;
+mod ordered;
+mod pass_through;
+mod pass_through_edges;
+mod pass_through_known;
+mod repeated;
+mod scoped_captures;
+mod simple_selections;
+mod slots;
+mod spread_repair;
+mod spread_selections;
+mod style_order;
+mod styled;
+mod type_imports;
+mod unreachable_styles;
+pub(crate) mod whole;
+
+const BOX: &str = "import { Box } from '@devup-ui/react';\n";
+const EMOTION: &str = "/** @jsxImportSource @emotion/react */\n";
+const JSX_RUNTIME: &str = "import { jsx } from 'react/jsx-runtime';\n";
+
+fn compile_with(code: &str, option: ExtractOption) -> Result {
+ reset_class_map();
+ reset_file_map();
+ css::debug::set_debug(true);
+ let output = extract("a.tsx", code, option).map_err(|error| error.to_string());
+ css::debug::set_debug(false);
+ output
+}
+
+fn compile(code: &str) -> Result {
+ compile_with(code, ExtractOption::default())
+}
+
+fn compile_emotion(code: &str) -> Result {
+ compile_with(
+ code,
+ ExtractOption {
+ import_aliases: HashMap::from([(
+ "@emotion/react".to_string(),
+ ImportAlias::NamedToNamed,
+ )]),
+ ..ExtractOption::default()
+ },
+ )
+}
+
+/// The output of a file that compiles
+fn output(source: &str) -> ExtractOutput {
+ compile(source).unwrap_or_else(|error| panic!("the file does not compile: {error}"))
+}
+
+fn code(source: &str) -> String {
+ output(source).code
+}
+
+/// The message of a file that does not compile
+fn error(source: &str) -> String {
+ compile(source)
+ .err()
+ .unwrap_or_else(|| panic!("the negative fixture compiles: {source}"))
+}
+
+fn static_styles(output: &ExtractOutput) -> Vec<(String, String)> {
+ let mut found: Vec<_> = output
+ .styles
+ .iter()
+ .filter_map(|style| match style {
+ ExtractStyleValue::Static(style) => {
+ Some((style.property().to_string(), style.value().to_string()))
+ }
+ _ => None,
+ })
+ .collect();
+ found.sort();
+ found
+}
+
+/// What the JavaScript `body` returns, run as the build's output runs it
+fn run(body: &str) -> String {
+ let script = format!("(function() {{ {body} }})()");
+ let mut context = boa_engine::Context::default();
+ let value = context
+ .eval(boa_engine::Source::from_bytes(script.as_bytes()))
+ .unwrap_or_else(|error| panic!("{error}: {script}"));
+ value.to_string(&mut context).map_or_else(
+ |error| panic!("{error}: {script}"),
+ |text| text.to_std_string_escaped(),
+ )
+}
diff --git a/libs/extractor/src/jsx_semantics_tests/binding_edges.rs b/libs/extractor/src/jsx_semantics_tests/binding_edges.rs
new file mode 100644
index 000000000..5b93ea601
--- /dev/null
+++ b/libs/extractor/src/jsx_semantics_tests/binding_edges.rs
@@ -0,0 +1,194 @@
+use super::whole::evaluate;
+use super::*;
+use rstest::rstest;
+use serial_test::serial;
+
+#[rstest]
+#[case("(Box)")]
+#[case("Box as typeof Box")]
+#[case("Box satisfies typeof Box")]
+#[serial]
+fn wrapped_component_bindings_when_create_element_reads_them_compile(#[case] component: &str) {
+ let source = format!(
+ "{BOX}import {{createElement}} from 'react'; export const a=()=>createElement({component},{{color:'red'}},'child');"
+ );
+ let actual = evaluate(&source, "a()");
+ assert_eq!(actual.element["type"], "div");
+ assert_eq!(actual.element["children"], serde_json::json!(["child"]));
+}
+
+#[test]
+#[serial]
+fn shadowed_undefined_when_used_as_props_is_forwarded() {
+ let source = format!(
+ "{BOX}import {{createElement}} from 'react';export const a=(undefined)=>createElement(Box,undefined,'child');"
+ );
+ let actual = evaluate(&source, "a({id:'kept'})");
+ assert_eq!(actual.element["props"]["id"], "kept");
+}
+
+#[test]
+#[serial]
+fn void_effect_when_used_as_props_runs_before_children() {
+ let source = format!(
+ "{BOX}import {{createElement}} from 'react';export const a=()=>createElement(Box,void trace.push('props'),(trace.push('children'),'child'));"
+ );
+ let actual = evaluate(&source, "a()");
+ assert_eq!(actual.trace, serde_json::json!(["props", "children"]));
+}
+
+#[rstest]
+#[case("undefined")]
+#[case("void effect()")]
+#[case("cond ? 1 : undefined")]
+#[case("cond ? void effect() : 2")]
+#[serial]
+fn uncertain_empty_order_when_shadowed_or_effectful_is_located(#[case] order: &str) {
+ for element in [
+ format!(""),
+ format!("jsx(Box,{{styleOrder:{order},color:'red'}})"),
+ ] {
+ let source =
+ format!("{BOX}{JSX_RUNTIME}export const a=(undefined,effect,cond)=>{element};");
+ let message = error(&source);
+ assert!(message.starts_with("a.tsx:3:"), "{message}");
+ assert!(message.contains(order), "{message}");
+ }
+}
+
+#[test]
+#[serial]
+fn shadowed_globals_when_spreads_copy_props_do_not_capture_generated_names() {
+ let source = format!(
+ "{BOX}export const a=(Object,undefined,__devupSpread0,__devupValue0)=> ;"
+ );
+ let actual = evaluate(&source, "a(null,'not-undefined',{color:void 0},'red')");
+ assert_eq!(
+ actual.element["props"]["className"]
+ .as_str()
+ .unwrap_or_else(|| panic!("class name: {}", actual.element))
+ .split_whitespace()
+ .count(),
+ 1
+ );
+ assert!(
+ actual.element["props"]["style"]
+ .as_object()
+ .unwrap_or_else(|| panic!("expected an authored style object"))
+ .values()
+ .any(|value| value == "red")
+ );
+}
+
+#[rstest]
+#[case("jsx(Box,{id:first(),as:type(),color:'red',...rest},child())")]
+#[case("createElement(Box,{id:first(),as:type(),color:'red',...rest},child())")]
+#[case("React.createElement(Box,{id:first(),as:type(),color:'red',...rest},child())")]
+#[serial]
+fn dynamic_as_when_props_are_captured_keeps_type_at_its_source_position(#[case] element: &str) {
+ let source = format!(
+ "{BOX}{JSX_RUNTIME}import React,{{createElement}} from 'react';export const a=(first,type,rest,child)=>{element};"
+ );
+ let actual = evaluate(
+ &source,
+ "a(()=>{trace.push('id');return 'id';},()=>{trace.push('type');return 'section';},{get color(){trace.push('spread');return 'blue';}},()=>{trace.push('child');return 'child';})",
+ );
+ assert_eq!(actual.element["type"], "section");
+ assert_eq!(
+ actual.trace,
+ serde_json::json!(["id", "type", "spread", "child"])
+ );
+}
+
+#[test]
+#[serial]
+fn dynamic_as_when_member_factory_looks_up_a_receiver_keeps_it() {
+ let source = format!(
+ "{BOX}import React from 'react';export const a=()=>React.createElement(Box,{{color:(trace.push('color'),'red'),as:(trace.push('type'),'a')}},(trace.push('child'),'child'));"
+ );
+ let actual = evaluate(
+ &source,
+ "(()=>{React.marker='receiver';Object.defineProperty(React,'createElement',{get(){trace.push('callee');return function(type,props,...children){return {type,props,children,receiver:this.marker};};}});return a();})()",
+ );
+ assert_eq!(actual.element["receiver"], "receiver");
+ assert_eq!(
+ actual.trace,
+ serde_json::json!(["callee", "color", "type", "child"])
+ );
+}
+
+#[test]
+#[serial]
+fn shadowed_undefined_when_a_conditional_style_is_absent_stays_absent() {
+ let source =
+ format!("{BOX}export const a=(undefined,active,value)=>;");
+ let actual = evaluate(&source, "a('incorrect',false,'red')");
+ assert!(
+ actual.element["props"]["style"]
+ .as_object()
+ .is_none_or(serde_json::Map::is_empty),
+ "{}",
+ actual.element
+ );
+}
+
+#[test]
+#[serial]
+fn locally_compiled_keyframes_when_capture_precedes_props_keep_static_rules() {
+ let source = "import {Box,keyframes} from '@devup-ui/react';export function a(props){const spin=keyframes({from:{opacity:0},to:{opacity:1}});return ;}";
+ let actual = output(source);
+ assert!(
+ static_styles(&actual)
+ .iter()
+ .any(|(property, _)| property == "animation-name"),
+ "{}",
+ actual.code
+ );
+ assert!(!actual.styles.iter().any(|style|matches!(style,ExtractStyleValue::Dynamic(style) if style.property()=="animation-name")),"{}",actual.code);
+}
+
+#[rstest]
+#[case("{take('child')}")]
+#[case("createElement(Box,{id:take('id'),as:type,...rest,title:take('title')},take('child'))")]
+#[serial]
+fn absent_dynamic_as_when_captured_defaults_without_reordering_later_props(#[case] element: &str) {
+ let source = format!(
+ "{BOX}import {{createElement}} from 'react';export const a=(type,rest,take)=>{element};"
+ );
+ let actual = evaluate(
+ &source,
+ "a(null,{get x(){trace.push('spread');return 1;}},key=>{trace.push(key);return key;})",
+ );
+ assert_eq!(actual.element["type"], "div");
+ assert_eq!(
+ actual.trace,
+ serde_json::json!(["id", "spread", "title", "child"])
+ );
+}
+
+#[rstest]
+#[case("({lg:'large',sm:'small'})[size]")]
+#[case("({lg:'large',sm:'small'} as const)[size]")]
+#[serial]
+fn wrapped_written_typography_when_captured_keeps_its_known_tokens(#[case] value: &str) {
+ let source = format!(
+ "{BOX}export const a=(size,rest)=>;"
+ );
+ let actual = output(&source);
+ assert!(
+ actual
+ .styles
+ .iter()
+ .any(|style| matches!(style,ExtractStyleValue::Typography(name) if name=="large")),
+ "{}",
+ actual.code
+ );
+ assert!(
+ actual
+ .styles
+ .iter()
+ .any(|style| matches!(style,ExtractStyleValue::Typography(name) if name=="small")),
+ "{}",
+ actual.code
+ );
+}
diff --git a/libs/extractor/src/jsx_semantics_tests/boundary_classes.rs b/libs/extractor/src/jsx_semantics_tests/boundary_classes.rs
new file mode 100644
index 000000000..a91184be9
--- /dev/null
+++ b/libs/extractor/src/jsx_semantics_tests/boundary_classes.rs
@@ -0,0 +1,220 @@
+use super::whole::evaluate;
+use super::*;
+use rstest::rstest;
+use serial_test::serial;
+
+#[test]
+#[serial]
+fn class_boundary_when_isolated_member_call_runs_keeps_receiver_getter_and_iterator_once() {
+ let source = format!(
+ "{BOX}export const a=(receiver,args)=>;"
+ );
+ let actual = evaluate(
+ &source,
+ "a({marker:'receiver',get read(){trace.push('get');return function(value){trace.push(this.marker+':'+value);return 'opaque';};}},{[Symbol.iterator](){trace.push('iterator');return ['arg'][Symbol.iterator]();}})",
+ );
+ assert_eq!(actual.element["props"]["className"], "opaque");
+ assert_eq!(
+ actual.trace,
+ serde_json::json!(["get", "iterator", "receiver:arg"])
+ );
+ assert!(!code(&source).contains("__devupValue"));
+}
+
+#[rstest]
+#[case("{get read(){trace.push('get');throw 'boom';}}", "[]", serde_json::json!(["get"]))]
+#[case("{get read(){trace.push('get');return ()=>{trace.push('call');};}}", "{[Symbol.iterator](){trace.push('iterator');throw 'boom';}}", serde_json::json!(["get","iterator"]))]
+#[case("{get read(){trace.push('get');return function(){trace.push('call');throw 'boom';};}}", "{[Symbol.iterator](){trace.push('iterator');return [][Symbol.iterator]();}}", serde_json::json!(["get","iterator","call"]))]
+#[serial]
+fn class_boundary_when_call_parts_throw_preserves_the_original_cutoff(
+ #[case] receiver: &str,
+ #[case] args: &str,
+ #[case] trace: serde_json::Value,
+) {
+ let source = format!(
+ "{BOX}export const a=(receiver,args)=>;"
+ );
+ let actual = evaluate(
+ &source,
+ &format!("(()=>{{try{{return a({receiver},{args});}}catch(error){{return error;}}}})()"),
+ );
+ assert_eq!(actual.element, "boom");
+ assert_eq!(actual.trace, trace);
+}
+
+#[rstest]
+#[case("", "'id'", "early", true)]
+#[case(
+ "",
+ "{className:'override'}",
+ "override",
+ true
+)]
+#[case(
+ "",
+ "'override'",
+ "override",
+ false
+)]
+#[serial]
+fn class_boundary_keeps_evaluation_order_and_only_captures_used_values(
+ #[case] element: &str,
+ #[case] later: &str,
+ #[case] expected: &str,
+ #[case] captured: bool,
+) {
+ let source = format!("{BOX}export const a=(read,later)=>{element};");
+ let actual = evaluate(
+ &source,
+ &format!(
+ "(()=>{{let value='early';return a(()=>{{trace.push('read');return value;}},()=>{{trace.push('later');value='late';return {later};}});}})()"
+ ),
+ );
+ assert_eq!(actual.trace, serde_json::json!(["read", "later"]));
+ assert_eq!(actual.element["props"]["className"], expected);
+ assert_eq!(code(&source).contains("__devupValue"), captured);
+}
+
+#[test]
+#[serial]
+fn class_boundary_when_style_order_expands_calls_still_evaluates_once() {
+ let source = format!(
+ "{BOX}export const a=(read,active)=>