;}const result=observe(()=>f(c));";
+ let ordered = "const props={get color(){trace.push('value');return 'purple';}};function before(){trace.push('before');return 'id';}function after(){trace.push('after');return 'title';}function f(props){return
;}const result=observe(()=>f(props));";
+ let cases = [
+ (
+ "mutable",
+ "classic",
+ mutable,
+ "ok",
+ vec!["factory", "value", "call:OLD"],
+ ),
+ (
+ "throw-identity",
+ "classic",
+ throwing,
+ "factory",
+ vec!["factory"],
+ ),
+ ("pragma-tdz", "pragma", tdz, "reference", vec![]),
+ (
+ "initializer",
+ "classic",
+ initializer,
+ "ok",
+ vec!["value", "factory", "call:NEW"],
+ ),
+ (
+ "duplicate-shorthand",
+ "classic",
+ shorthand,
+ "ok",
+ vec!["factory", "position", "call:OLD"],
+ ),
+ (
+ "dynamic-template",
+ "classic",
+ template,
+ "ok",
+ vec!["factory", "coerce", "call:OLD"],
+ ),
+ (
+ "ordered-refusal",
+ "classic",
+ ordered,
+ "ok",
+ vec!["factory", "before", "value", "after", "call:OLD"],
+ ),
+ (
+ "mutable",
+ "automatic",
+ mutable,
+ "ok",
+ vec!["value", "call:AUTO"],
+ ),
+ (
+ "throw-identity",
+ "automatic",
+ throwing,
+ "value",
+ vec!["value"],
+ ),
+ (
+ "dynamic-template",
+ "automatic",
+ template,
+ "ok",
+ vec!["coerce", "call:AUTO"],
+ ),
+ (
+ "ordered-refusal",
+ "automatic",
+ ordered,
+ "ok",
+ vec!["before", "value", "after", "call:AUTO"],
+ ),
+ ];
+ let prelude = "const trace=[];const factoryError={},valueError={};let active='OLD',factoryThrows=false;const Box='div';function automatic(type,props){trace.push('call:AUTO');return {type,props};}const React={get createElement(){trace.push('factory');if(factoryThrows)throw factoryError;const selected=active;return (type,props)=>{trace.push('call:'+selected);return {type,props};};}};function observe(invoke){try{invoke();return 'ok';}catch(error){return error===factoryError?'factory':error===valueError?'value':error instanceof ReferenceError?'reference':'other';}}";
+ for (id, runtime, body, outcome, trace) in cases {
+ let source = if id == "duplicate-shorthand" {
+ format!("import {{Box}} from '@devup-ui/react';{body}")
+ } else {
+ format!("{prefix}{body}")
+ };
+ let authored_script = factory_script(&source, runtime);
+ let authored_text = run(&format!(
+ "{prelude}{authored_script}\nreturn JSON.stringify({{outcome:result,trace}});"
+ ));
+ let authored: serde_json::Value = serde_json::from_str(&authored_text)
+ .unwrap_or_else(|error| panic!("{error}: {authored_text}"));
+ assert_eq!(
+ authored,
+ serde_json::json!({"outcome":outcome,"trace":trace}),
+ "authored {id}/{runtime}"
+ );
+ for single_css in [false, true] {
+ reset_class_map();
+ reset_file_map();
+ let options = ExtractOption {
+ single_css,
+ import_aliases: HashMap::from([(
+ "@emotion/react".into(),
+ ImportAlias::NamedToNamed,
+ )]),
+ ..ExtractOption::default()
+ };
+ let output = extract("factory.tsx", &source, options)
+ .unwrap_or_else(|error| panic!("{id}/{runtime}/{single_css}: {error}"));
+ let script = factory_script(&output.code, runtime);
+ let current_text = run(&format!(
+ "{prelude}{script}\nreturn JSON.stringify({{outcome:result,trace}});"
+ ));
+ let current: serde_json::Value = serde_json::from_str(¤t_text)
+ .unwrap_or_else(|error| panic!("{error}: {current_text}"));
+ if id == "duplicate-shorthand" {
+ assert_eq!(
+ current["trace"]
+ .as_array()
+ .map(|rows| rows.iter().filter(|v| *v == "position").count()),
+ Some(1)
+ );
+ }
+ assert_eq!(
+ current, authored,
+ "{id}/{runtime}/{single_css}: {}",
+ output.code
+ );
+ }
+ }
+}
+
+struct RestoreDebug(bool);
+impl Drop for RestoreDebug {
+ fn drop(&mut self) {
+ css::debug::set_debug(self.0);
+ }
+}
+
+#[test]
+#[serial_test::serial]
+fn public_dynamic_identifiers_match_emitted_style_expressions() {
+ use oxc_ast_visit::{Visit, walk};
+ struct Slots(Vec<(String, String)>);
+ impl<'a> Visit<'a> for Slots {
+ fn visit_object_property(&mut self, property: &oxc_ast::ast::ObjectProperty<'a>) {
+ if let Some(key) = property.key.static_name().map(|key| {
+ key.into_cow_str()
+ .unwrap_or_else(|| panic!("non-UTF-8 static property key"))
+ }) && key.starts_with("--")
+ {
+ self.0.push((
+ key.into_owned(),
+ crate::utils::readable_code(&property.value),
+ ));
+ }
+ walk::walk_object_property(self, property);
+ }
+ }
+ let _restore_debug = RestoreDebug(css::debug::is_debug());
+ css::debug::set_debug(false);
+ for (body, expected) in [
+ ("color: props.color", "props.color"),
+ ("padding: gap * 4", "gap * 4"),
+ ("color: `${c}`", "c"),
+ ] {
+ let source = format!(
+ "import {{css}} from '@emotion/react';function f(props,gap,c){{return
;}}"
+ );
+ reset_class_map();
+ reset_file_map();
+ let output = extract(
+ "a.tsx",
+ &source,
+ ExtractOption {
+ import_aliases: HashMap::from([(
+ "@emotion/react".into(),
+ ImportAlias::NamedToNamed,
+ )]),
+ ..ExtractOption::default()
+ },
+ )
+ .unwrap_or_else(|error| panic!("{error}"));
+ let arena = oxc_allocator::Allocator::default();
+ let parsed =
+ oxc_parser::Parser::new(&arena, &output.code, oxc_span::SourceType::tsx()).parse();
+ assert!(!parsed.fatal_error && parsed.diagnostics.is_empty());
+ let mut slots = Slots(Vec::new());
+ slots.visit_program(&parsed.program);
+ assert_eq!(slots.0.len(), 1, "{}", output.code);
+ assert_eq!(
+ output
+ .styles
+ .iter()
+ .filter(|style| matches!(style, ExtractStyleValue::Dynamic(_)))
+ .count(),
+ 1
+ );
+ for style in &output.styles {
+ if let ExtractStyleValue::Dynamic(style) = style {
+ let StyleProperty::Variable {
+ variable_name,
+ identifier,
+ ..
+ } = style.extract(Some("a.tsx"))
+ else {
+ panic!("dynamic style has no variable");
+ };
+ assert!(identifier.contains(expected), "{identifier}");
+ let expression =
+ oxc_parser::Parser::new(&arena, &identifier, oxc_span::SourceType::tsx())
+ .parse_expression()
+ .unwrap_or_else(|error| panic!("{error:?}"));
+ assert_eq!(
+ slots.0,
+ vec![(variable_name, crate::utils::readable_code(&expression))]
+ );
+ }
+ }
+ }
+}
+
+#[test]
+#[serial_test::serial]
+fn rewriting_one_owner_preserves_other_sites_and_capture_fallbacks() {
+ use oxc_ast_visit::{Visit, walk};
+ use oxc_span::ContentEq;
+ struct Slots(Vec<(String, String)>);
+ impl<'a> Visit<'a> for Slots {
+ fn visit_object_property(&mut self, property: &oxc_ast::ast::ObjectProperty<'a>) {
+ if let Some(key) = property.key.static_name().map(|key| {
+ key.into_cow_str()
+ .unwrap_or_else(|| panic!("non-UTF-8 static property key"))
+ }) && key.starts_with("--")
+ {
+ self.0.push((
+ key.into_owned(),
+ crate::utils::readable_code(&property.value),
+ ));
+ }
+ walk::walk_object_property(self, property);
+ }
+ }
+ let _restore_debug = RestoreDebug(css::debug::is_debug());
+ css::debug::set_debug(false);
+ for body in [
+ "const a=
;const b=