")));
+ assert!(runtime.code.contains("styles = {"), "{}", runtime.code);
+ assert!(
+ runtime.code.contains("holder.value = {"),
+ "{}",
+ runtime.code
+ );
+ assert!(runtime.code.contains("callback(value)"), "{}", runtime.code);
+ assert!(
+ runtime.code.matches("_tsrx_style_ref_").count() >= 2,
+ "{}",
+ runtime.code
+ );
+
+ let expression = compile_tsrx(
+ "const ignored = () => {}; export const styles = ;",
+ "expression-ref.tsrx",
+ );
+ assert!(
+ expression.code.contains(&format!(
+ "\"foo\": \"{} foo\"",
+ expression.css_hash.unwrap()
+ )),
+ "{}",
+ expression.code
+ );
+ }
+
+ #[cfg(feature = "tsrx")]
+ #[test]
+ fn leaves_unowned_styles_unextracted_and_keeps_owner_visitor_order() {
+ let unowned = compile_tsrx(
+ ";",
+ "unowned-style.tsrx",
+ );
+ assert_eq!(unowned.css.as_deref(), Some(""));
+ assert_eq!(unowned.css_hash, None);
+
+ let ordered = compile_tsrx(
+ r#"export function View() @{
+ const early = ;
+ <>
+
+
+
+}"#,
+ "style-owner-order.tsrx",
+ );
+ let css = ordered.css.as_deref().unwrap();
+ assert!(
+ css.find(".owner").unwrap() < css.find(".early").unwrap(),
+ "{css}"
+ );
+ }
+
+ #[cfg(feature = "tsrx")]
+ #[test]
+ fn import_source_skip_preserves_authored_tsrx_while_compiled_tsrx_emits_maps() {
+ let source = "export const view = <>
;";
+ let skipped = compile(
+ source,
+ &CompileOptions {
+ filename: Some("skip.tsrx".into()),
+ syntax: Syntax::Tsrx,
+ require_import_source: Some("solid-js".into()),
+ source_map: true,
+ ..CompileOptions::default()
+ },
+ )
+ .unwrap();
+ assert_eq!(skipped.code, source);
+ assert!(skipped.css.as_deref().is_some_and(|css| !css.is_empty()));
+ assert!(skipped.css_hash.is_some());
+ assert_eq!(skipped.source_map, None);
+
+ let tsrx = compile(
+ source,
+ &CompileOptions {
+ filename: Some("mapped.tsrx".into()),
+ syntax: Syntax::Tsrx,
+ source_map: true,
+ ..CompileOptions::default()
+ },
+ )
+ .unwrap();
+ let map = tsrx
+ .source_map
+ .as_deref()
+ .expect("compiled TSRX source map");
+ assert!(map.contains("\"sources\":[\"mapped.tsrx\"]"), "{map}");
+ assert!(map.contains("\"sourcesContent\""), "{map}");
+
+ let jsx = compile(
+ "export const view =
;",
+ &CompileOptions {
+ filename: Some("mapped.tsx".into()),
+ source_map: true,
+ ..CompileOptions::default()
+ },
+ )
+ .unwrap();
+ assert!(jsx.source_map.is_some());
+ }
}
diff --git a/packages/compiler/src/config.rs b/packages/compiler/src/config.rs
index 402474ad9..872d56671 100644
--- a/packages/compiler/src/config.rs
+++ b/packages/compiler/src/config.rs
@@ -14,6 +14,10 @@ pub struct RendererOption {
#[derive(Default)]
pub struct TransformOptions {
pub filename: Option
,
+ /// Source syntax routing, matching `@solidjs/babel-plugin`'s `syntax`:
+ /// `"auto"` (default) compiles `.tsrx` filenames with the TSRX frontend,
+ /// `"jsx"` never does, `"tsrx"` forces TSRX for every file.
+ pub syntax: Option,
/// Runtime module compiled output imports helpers from.
/// Default `"@solidjs/web"`.
pub module_name: Option,
@@ -64,9 +68,18 @@ pub struct TransformOptions {
pub struct TransformResult {
pub code: String,
pub map: Option,
+ /// Extracted TSRX stylesheet output. Absent for ordinary JSX transforms.
+ pub css: Option,
+ /// Space-separated TSRX scope hashes. Absent when no stylesheet was emitted.
+ pub css_hash: Option,
}
pub(crate) fn source_type_for_filename(filename: Option<&str>) -> Result {
+ if filename.is_some_and(|filename| filename.ends_with(".tsrx")) {
+ // Secondary passes receive already-projected ordinary code but retain
+ // the authored filename for stable path-derived metadata.
+ return Ok(SourceType::tsx());
+ }
filename
.map(SourceType::from_path)
.transpose()
diff --git a/packages/compiler/src/dom/children.rs b/packages/compiler/src/dom/children.rs
index 10fe2ef6e..5ff9decf2 100644
--- a/packages/compiler/src/dom/children.rs
+++ b/packages/compiler/src/dom/children.rs
@@ -111,10 +111,15 @@ impl<'a> AstDomTransform<'a, '_> {
// (`detectExpressions`), even if nothing ends up
// referencing it. Nodes without ids don't consume
// a walk position (Babel's `i` counts ids only).
- if filtered_index(child).is_some_and(|position| {
- self.detect_expressions(&filtered, position)
- }) {
- let name = self.next_element_id();
+ // A preceding dynamic slot may have already
+ // claimed this node's id as its insert marker.
+ let claimed = self.pending_child_walk.take();
+ if claimed.is_some()
+ || filtered_index(child).is_some_and(|position| {
+ self.detect_expressions(&filtered, position)
+ })
+ {
+ let name = claimed.unwrap_or_else(|| self.next_element_id());
let lookup = self.child_walk_expression(
element.span,
element_id,
@@ -178,11 +183,14 @@ impl<'a> AstDomTransform<'a, '_> {
// position; the walk is emitted even though unused.
// In dev hydratable mode the walk validates the tag
// (`getFirstChild`/`getNextSibling`).
- if filtered_index(&element.children[index])
- .is_some_and(|position| self.detect_expressions(&filtered, position))
+ let claimed = self.pending_child_walk.take();
+ if claimed.is_some()
+ || filtered_index(&element.children[index]).is_some_and(|position| {
+ self.detect_expressions(&filtered, position)
+ })
{
let child_tag = element_name(&child.opening_element.name)?;
- let name = self.next_element_id();
+ let name = claimed.unwrap_or_else(|| self.next_element_id());
let lookup = self.child_element_expression(
child.span,
element_id,
@@ -230,10 +238,13 @@ impl<'a> AstDomTransform<'a, '_> {
if let Some(value) = self.static_jsx_expression_value(&container.expression) {
template.push_both(&escape_html_text_expression(&value));
if !in_text_run {
- if filtered_index(child).is_some_and(|position| {
- self.detect_expressions(&filtered, position)
- }) {
- let name = self.next_element_id();
+ let claimed = self.pending_child_walk.take();
+ if claimed.is_some()
+ || filtered_index(child).is_some_and(|position| {
+ self.detect_expressions(&filtered, position)
+ })
+ {
+ let name = claimed.unwrap_or_else(|| self.next_element_id());
let lookup = self.child_walk_expression(
element.span,
element_id,
@@ -614,9 +625,11 @@ impl<'a> AstDomTransform<'a, '_> {
initial: None,
});
}
- if has_following_static_content(&children[following_start..]) {
+ // Babel's `nextChild(childNodes, index)`: the marker is the first
+ // following sibling's positional id when one will exist.
+ if let Some(marker) = self.claim_following_walk(children, following_start, span) {
return Some(InsertMarker {
- marker: self.child_walk_expression(span, element_id, *child_node_index),
+ marker,
initial: None,
});
}
@@ -690,10 +703,12 @@ impl<'a> AstDomTransform<'a, '_> {
template: &mut crate::dom::template::TemplateHtml,
declarations: &mut std::vec::Vec>,
) -> Expression<'a> {
+ // Babel: `exprId = childNodes[index + 1].id` — ride the immediately
+ // following sibling's positional id when it will exist.
if !self.slot_boxed_by_text(children, index)
- && self.next_child_is_template_node(children, index)
+ && let Some(marker) = self.claim_following_walk(children, index + 1, span)
{
- return self.child_walk_expression(span, element_id, *child_node_index);
+ return marker;
}
self.dedicated_slot_placeholder(span, element_id, child_node_index, template, declarations)
}
@@ -758,12 +773,23 @@ impl<'a> AstDomTransform<'a, '_> {
false
}
- /// Whether the immediately following retained child contributes a template
- /// node (non-empty text, static expression, or native element) that can
- /// serve as this slot's marker.
- fn next_child_is_template_node(&self, children: &[JSXChild<'a>], index: usize) -> bool {
- for child in &children[index + 1..] {
- return match child {
+ /// Babel rides the immediately following sibling's positional id as the
+ /// slot's marker (`childNodes[index + 1].id` per-slot, `nextChild` in the
+ /// multi branch) — the id its own transform declares. When the first
+ /// retained child at/after `start` is a template node (non-empty text,
+ /// static expression, native element) that will receive a positional id
+ /// (its lowering guard mirrors `detectExpressions`), allocate that name
+ /// now, park it in `pending_child_walk` for the child's lowering to
+ /// declare, and return a reference to it.
+ fn claim_following_walk(
+ &mut self,
+ children: &[JSXChild<'a>],
+ start: usize,
+ span: oxc_span::Span,
+ ) -> Option> {
+ let mut following: Option<&JSXChild<'a>> = None;
+ for child in &children[start..] {
+ let is_template_node = match child {
JSXChild::Text(text) => {
if trim_jsx_text(&text.value).is_empty() {
continue;
@@ -780,8 +806,35 @@ impl<'a> AstDomTransform<'a, '_> {
JSXChild::Element(child) => !is_component_name(&child.opening_element.name),
_ => false,
};
+ if is_template_node {
+ following = Some(child);
+ }
+ break;
}
- false
+ let following = following?;
+ // The sibling's walk declaration is guarded by `detectExpressions`
+ // over the filtered child list; only claim an id the sibling will
+ // actually declare. (Dynamic native elements always declare, but a
+ // dynamic slot immediately before them makes the detect true anyway.)
+ let filtered: std::vec::Vec<&JSXChild<'a>> = children
+ .iter()
+ .filter(|child| match child {
+ JSXChild::Text(text) => !trim_jsx_text(&text.value).is_empty(),
+ JSXChild::ExpressionContainer(container) => {
+ !matches!(container.expression, JSXExpression::EmptyExpression(_))
+ }
+ _ => true,
+ })
+ .collect();
+ let position = filtered
+ .iter()
+ .position(|candidate| std::ptr::eq(*candidate, following))?;
+ if !self.detect_expressions(&filtered, position) {
+ return None;
+ }
+ let name = self.next_element_id();
+ self.pending_child_walk = Some(name.clone());
+ Some(self.identifier_expression(span, &name))
}
/// `getNextMatch(.nextSibling | .firstChild, "")`
@@ -843,7 +896,12 @@ impl<'a> AstDomTransform<'a, '_> {
child
};
let mut child_template = crate::dom::template::TemplateHtml::open_tag(&tag_name);
- let child_id = self.next_element_id();
+ // A preceding dynamic slot may have claimed this element's id as its
+ // insert marker (Babel's `childNodes[index + 1].id`).
+ let child_id = self
+ .pending_child_walk
+ .take()
+ .unwrap_or_else(|| self.next_element_id());
let mut child_declarations = std::vec::Vec::new();
let mut child_operations = std::vec::Vec::new();
@@ -987,18 +1045,6 @@ fn spread_child_expression<'a>(
}
}
-fn has_following_static_content(children: &[JSXChild<'_>]) -> bool {
- children.iter().any(|child| match child {
- JSXChild::Text(text) => !trim_jsx_text(&text.value).is_empty(),
- JSXChild::ExpressionContainer(container) => {
- !matches!(container.expression, JSXExpression::EmptyExpression(_))
- && static_jsx_expression(&container.expression, None).is_some()
- }
- JSXChild::Element(child) => !is_component_name(&child.opening_element.name),
- _ => false,
- })
-}
-
fn has_previous_static_text(children: &[JSXChild<'_>]) -> bool {
children.iter().rev().any(|child| match child {
JSXChild::Text(text) => !trim_jsx_text(&text.value).is_empty(),
diff --git a/packages/compiler/src/dom/element.rs b/packages/compiler/src/dom/element.rs
index 5b293360b..710efa4bd 100644
--- a/packages/compiler/src/dom/element.rs
+++ b/packages/compiler/src/dom/element.rs
@@ -86,6 +86,12 @@ pub(crate) struct AstDomTransform<'a, 'source> {
/// (`getFirstChild`/`getNextSibling`) chain from it by name — the plain
/// member walks re-derive from the root instead (equalized by traversal).
pub(crate) last_child_walk: Option<(String, usize)>,
+ /// A positional walk name pre-allocated by a dynamic slot's marker for
+ /// the immediately following template child (Babel rides
+ /// `childNodes[index + 1].id` / `nextChild`, which the sibling's own
+ /// transform declares). The next retained child's lowering must consume
+ /// this instead of allocating a fresh id.
+ pub(crate) pending_child_walk: Option,
/// Whether the current template root saw a delegated event handler or a
/// spread (which may carry one); consumed at the root to emit a single
/// `runHydrationEvents()` after setup.
@@ -185,6 +191,7 @@ impl<'a, 'source> AstDomTransform<'a, 'source> {
skip_xmlns_attribute: false,
hydration_walk_anchor: None,
last_child_walk: None,
+ pending_child_walk: None,
has_hydratable_event: false,
element_index: 0,
this_index: 0,
@@ -380,10 +387,10 @@ impl<'a, 'source> AstDomTransform<'a, 'source> {
subject: patched_subject.clone(),
});
}
- if patched_subject.is_none() {
- if let Some(statement) = self.wrap_dynamics_statement(dynamics) {
- operations.push(statement);
- }
+ if patched_subject.is_none()
+ && let Some(statement) = self.wrap_dynamics_statement(dynamics)
+ {
+ operations.push(statement);
}
if self.should_close_tag(&tag_name, CloseTagContext::root()) {
template.html.push_str(&format!(""));
diff --git a/packages/compiler/src/lazy.rs b/packages/compiler/src/lazy.rs
index 332dd5bd4..23694da4f 100644
--- a/packages/compiler/src/lazy.rs
+++ b/packages/compiler/src/lazy.rs
@@ -50,7 +50,12 @@ pub fn transform_lazy(
) -> Result {
let options = options.unwrap_or_default();
let Some(filename) = options.filename.as_deref() else {
- return Ok(TransformResult { code, map: None });
+ return Ok(TransformResult {
+ code,
+ map: None,
+ css: None,
+ css_hash: None,
+ });
};
let source_type = source_type_for_filename(Some(filename))?;
@@ -71,7 +76,12 @@ pub fn transform_lazy(
// Nothing matched: hand back the input untouched instead of a
// reprint (the Babel support pass reprints regardless, but callers
// only care about the placeholder injection).
- return Ok(TransformResult { code, map: None });
+ return Ok(TransformResult {
+ code,
+ map: None,
+ css: None,
+ css_hash: None,
+ });
}
let mut rewriter = Rewriter {
@@ -93,6 +103,8 @@ pub fn transform_lazy(
Ok(TransformResult {
code: build.code,
map: build.map.map(|map| map.to_json_string()),
+ css: None,
+ css_hash: None,
})
}
diff --git a/packages/compiler/src/lib.rs b/packages/compiler/src/lib.rs
index a20fb5694..bf5b50e19 100644
--- a/packages/compiler/src/lib.rs
+++ b/packages/compiler/src/lib.rs
@@ -29,10 +29,17 @@ mod node_adapter;
mod refresh;
mod shared;
mod ssr;
+#[cfg(feature = "tsrx")]
+mod tsrx;
mod universal;
-pub use compiler::{CompileOptions, CompileOutput, Generate, Renderer, Wrapper, compile};
+pub use compiler::{CompileOptions, CompileOutput, Generate, Renderer, Syntax, Wrapper, compile};
pub use error::{CompileError, CompileErrorKind};
+#[cfg(feature = "tsrx")]
+pub use tsrx::{
+ TsrxEmbeddedRegion, TsrxEmbeddedRegionKind, TsrxTypecheckProjection,
+ TsrxTypecheckProjectionOptions, project_tsrx_for_typecheck,
+};
#[cfg(feature = "node")]
pub use node_adapter::*;
diff --git a/packages/compiler/src/node_adapter.rs b/packages/compiler/src/node_adapter.rs
index 9407a4e67..b054edc49 100644
--- a/packages/compiler/src/node_adapter.rs
+++ b/packages/compiler/src/node_adapter.rs
@@ -11,11 +11,120 @@ pub use crate::directives::{
};
pub use crate::lazy::TransformLazyOptions;
pub use crate::refresh::TransformRefreshOptions;
-use crate::{CompileOptions, Generate, Renderer, Wrapper};
+use crate::{CompileOptions, Generate, Renderer, Syntax, Wrapper};
const UNSUPPORTED_GENERATE: &str =
"The @solidjs/compiler backend implements DOM, SSR, universal, and dynamic modes only";
+#[cfg(feature = "tsrx")]
+#[napi(object)]
+#[derive(Default)]
+pub struct ProjectTsrxForTypecheckOptions {
+ pub filename: Option,
+}
+
+#[cfg(feature = "tsrx")]
+#[napi(object)]
+pub struct TsrxTypecheckEmbeddedRegion {
+ pub kind: String,
+ /// Authored JavaScript string offset in UTF-16 code units.
+ pub start: u32,
+ /// Authored JavaScript string offset in UTF-16 code units.
+ pub end: u32,
+ pub content: String,
+}
+
+#[cfg(feature = "tsrx")]
+#[napi(object)]
+pub struct TsrxTypecheckProjectionResult {
+ pub code: String,
+ pub map: String,
+ pub css: String,
+ pub css_hash: Option,
+ pub embedded_regions: Vec,
+}
+
+/// Experimental host-independent TSRX projection for typechecking tools.
+#[cfg(feature = "tsrx")]
+#[napi]
+pub fn project_tsrx_for_typecheck(
+ code: String,
+ options: Option,
+) -> Result {
+ let options = options.unwrap_or_default();
+ let output = crate::tsrx::project_tsrx_for_typecheck(
+ &code,
+ &crate::tsrx::TsrxTypecheckProjectionOptions {
+ filename: options.filename,
+ },
+ )
+ .map_err(|error| Error::from_reason(error.to_string()))?;
+ let endpoints = output
+ .embedded_regions
+ .iter()
+ .flat_map(|region| [region.start, region.end])
+ .collect::>();
+ let utf16_endpoints = utf16_offsets(&code, &endpoints)?;
+ let embedded_regions = output
+ .embedded_regions
+ .into_iter()
+ .zip(utf16_endpoints.chunks_exact(2))
+ .map(|(region, offsets)| {
+ let kind = match region.kind {
+ crate::tsrx::TsrxEmbeddedRegionKind::Css => "css",
+ crate::tsrx::TsrxEmbeddedRegionKind::Script => "script",
+ };
+ TsrxTypecheckEmbeddedRegion {
+ kind: kind.into(),
+ start: offsets[0],
+ end: offsets[1],
+ content: region.content,
+ }
+ })
+ .collect();
+ Ok(TsrxTypecheckProjectionResult {
+ code: output.code,
+ map: output.source_map,
+ css: output.css,
+ css_hash: output.css_hash,
+ embedded_regions,
+ })
+}
+
+#[cfg(feature = "tsrx")]
+fn utf16_offsets(source: &str, byte_offsets: &[u32]) -> Result> {
+ let mut indexed = byte_offsets.iter().copied().enumerate().collect::>();
+ indexed.sort_unstable_by_key(|(_, offset)| *offset);
+ let mut converted = vec![0; byte_offsets.len()];
+ let mut byte = 0usize;
+ let mut utf16 = 0usize;
+ for (index, target) in indexed {
+ let target = target as usize;
+ if target > source.len() {
+ return Err(Error::from_reason(
+ "TSRX embedded region exceeds the source length",
+ ));
+ }
+ while byte < target {
+ let character = source[byte..]
+ .chars()
+ .next()
+ .ok_or_else(|| Error::from_reason("TSRX embedded region exceeds the source"))?;
+ byte += character.len_utf8();
+ utf16 += character.len_utf16();
+ }
+ if byte != target {
+ return Err(Error::from_reason(
+ "TSRX embedded region is not on a UTF-8 boundary",
+ ));
+ }
+ converted[index] = u32::try_from(utf16).map_err(|_| {
+ Error::from_reason("TSRX embedded region exceeds the N-API offset range")
+ })?;
+ }
+ Ok(converted)
+}
+
/// The `"use server"` directive pass — a second, independent transform over
/// the same parse infrastructure as the JSX pass. Applies to plain
/// `.js`/`.ts` modules as well as JSX/TSX.
@@ -66,6 +175,8 @@ pub fn transform(code: String, options: Option) -> Result Result {
"dynamic" => Generate::Dynamic,
_ => return Err(Error::from_reason(UNSUPPORTED_GENERATE)),
};
+ // Same fallthrough as the Babel plugin's `isTsrxSource`: any value other
+ // than "tsrx"/"jsx" behaves as "auto".
+ let syntax = match options.syntax.as_deref() {
+ Some("tsrx") => Syntax::Tsrx,
+ Some("jsx") => Syntax::Jsx,
+ _ => Syntax::Auto,
+ };
Ok(CompileOptions {
filename: options.filename,
+ syntax,
module_name,
generate,
hydratable: options.hydratable.unwrap_or(false),
@@ -149,6 +268,8 @@ fn legacy_preflight(
return Ok(TransformResult {
code: code.to_owned(),
map: None,
+ css: None,
+ css_hash: None,
});
}
Err(Error::from_reason(validation_error))
@@ -268,4 +389,27 @@ mod tests {
)
.expect("next accepts an explicitly empty moduleName");
}
+
+ #[cfg(feature = "tsrx")]
+ #[test]
+ fn typecheck_projection_converts_all_embedded_offsets_in_one_utf16_pass() {
+ let source = "const marker = \"🚀\"; export const C = () => <>;";
+ let output = project_tsrx_for_typecheck(
+ source.into(),
+ Some(ProjectTsrxForTypecheckOptions {
+ filename: Some("offsets.tsrx".into()),
+ }),
+ )
+ .expect("TSRX typecheck projection");
+ assert_eq!(output.embedded_regions.len(), 2);
+ for region in output.embedded_regions {
+ let byte_start = source.find(®ion.content).expect("embedded content");
+ let byte_end = byte_start + region.content.len();
+ assert_eq!(
+ region.start,
+ source[..byte_start].encode_utf16().count() as u32
+ );
+ assert_eq!(region.end, source[..byte_end].encode_utf16().count() as u32);
+ }
+ }
}
diff --git a/packages/compiler/src/refresh/mod.rs b/packages/compiler/src/refresh/mod.rs
index 61022fb3b..8a12665a6 100644
--- a/packages/compiler/src/refresh/mod.rs
+++ b/packages/compiler/src/refresh/mod.rs
@@ -112,7 +112,12 @@ pub fn transform_refresh(
if !changed {
// Skipped modules (`@refresh skip`) and modules with nothing to
// register come back untouched.
- return Ok(TransformResult { code, map: None });
+ return Ok(TransformResult {
+ code,
+ map: None,
+ css: None,
+ css_hash: None,
+ });
}
let build = Codegen::new()
@@ -127,5 +132,7 @@ pub fn transform_refresh(
Ok(TransformResult {
code: build.code,
map: build.map.map(|map| map.to_json_string()),
+ css: None,
+ css_hash: None,
})
}
diff --git a/packages/compiler/src/shared/ast_builder.rs b/packages/compiler/src/shared/ast_builder.rs
index f616494ab..1dee1cc22 100644
--- a/packages/compiler/src/shared/ast_builder.rs
+++ b/packages/compiler/src/shared/ast_builder.rs
@@ -12,7 +12,9 @@ use oxc_span::Span;
use oxc_str::{Ident, Str};
use oxc_syntax::{
number::NumberBase,
- operator::{AssignmentOperator, BinaryOperator, LogicalOperator, UnaryOperator},
+ operator::{
+ AssignmentOperator, BinaryOperator, LogicalOperator, UnaryOperator, UpdateOperator,
+ },
};
#[derive(Clone, Copy)]
@@ -215,6 +217,16 @@ impl<'a> AstBuilder<'a> {
Expression::new_unary_expression(span, operator, argument, &self.inner())
}
+ pub(crate) fn expression_update(
+ &self,
+ span: Span,
+ operator: UpdateOperator,
+ prefix: bool,
+ argument: SimpleAssignmentTarget<'a>,
+ ) -> Expression<'a> {
+ Expression::new_update_expression(span, operator, prefix, argument, &self.inner())
+ }
+
#[allow(clippy::too_many_arguments)]
pub(crate) fn expression_function(
&self,
@@ -686,6 +698,35 @@ impl<'a> AstBuilder<'a> {
JSXExpressionContainer::new(span, expression, &self.inner())
}
+ pub(crate) fn jsx_attribute_item_expression(
+ &self,
+ span: Span,
+ name: &str,
+ expression: Expression<'a>,
+ ) -> JSXAttributeItem<'a> {
+ JSXAttributeItem::Attribute(JSXAttribute::boxed(
+ span,
+ JSXAttributeName::Identifier(JSXIdentifier::boxed(span, self.str(name), &self.inner())),
+ Some(JSXAttributeValue::ExpressionContainer(
+ JSXExpressionContainer::boxed(span, expression.into(), &self.inner()),
+ )),
+ &self.inner(),
+ ))
+ }
+
+ pub(crate) fn jsx_identifier(&self, span: Span, name: impl Into>) -> JSXIdentifier<'a> {
+ JSXIdentifier::new(span, name, &self.inner())
+ }
+
+ pub(crate) fn alloc_jsx_member_expression(
+ &self,
+ span: Span,
+ object: JSXMemberExpressionObject<'a>,
+ property: JSXIdentifier<'a>,
+ ) -> ArenaBox<'a, JSXMemberExpression<'a>> {
+ JSXMemberExpression::boxed(span, object, property, &self.inner())
+ }
+
pub(crate) fn template_element_with_lone_surrogates(
&self,
span: Span,
diff --git a/packages/compiler/src/tsrx/mod.rs b/packages/compiler/src/tsrx/mod.rs
new file mode 100644
index 000000000..3e905e2d9
--- /dev/null
+++ b/packages/compiler/src/tsrx/mod.rs
@@ -0,0 +1,223 @@
+//! TSRX syntax frontend (feature `tsrx`).
+//!
+//! Routes `.tsrx` sources through `tsrx_parser_engine` (the community
+//! `oxc-tsrx` project, pinned by revision — the only TSRX grammar authority
+//! on the Rust side), lowers parser interchange into compiler-owned typed
+//! Solid TSRX semantic IR, projects that IR to Solid builtIn JSX over the
+//! authored source, reparses the projection with the crate's own oxc, and
+//! finishes with symbol-exact lazy/accessor rewrites. The desugaring contract
+//! is frozen by `@solidjs/babel-plugin/src/tsrx/desugar.ts` and its fixture
+//! corpus; both frontends must lower identically.
+
+mod names;
+mod project;
+mod rewrite;
+mod semantic;
+mod source_map;
+mod style;
+mod style_projection;
+mod tape;
+mod tooling;
+
+pub use project::Projection;
+pub use tooling::{
+ TsrxEmbeddedRegion, TsrxEmbeddedRegionKind, TsrxTypecheckProjection,
+ TsrxTypecheckProjectionOptions, project_tsrx_for_typecheck,
+};
+
+use tsrx_parser_engine::{
+ TsrxParseOptions, TsrxParseRequest, TsrxParseResult, TsrxUtf16ParseRequest,
+ parse_tsrx_utf16_with_options, parse_tsrx_with_options,
+};
+use tsrx_tape_schema::{CoordinateDomain, ParseCompleteness, RecordIndex, ValueRef};
+
+use crate::error::CompileError;
+
+/// Parse TSRX source and project it to plain TSX for the shared pipeline.
+pub fn run_frontend(
+ source: &str,
+ filename: Option<&str>,
+ source_maps: bool,
+) -> Result {
+ let filename = filename.unwrap_or("input.tsrx");
+ let options = TsrxParseOptions {
+ filename,
+ include_ts_fields: true,
+ ..TsrxParseOptions::default()
+ };
+
+ let result = parse_source(source, options)?;
+ if result.status != ParseCompleteness::Complete {
+ return Err(first_diagnostic_error(source, &result));
+ }
+ let mut tape = result
+ .program
+ .ok_or_else(|| CompileError::parse("TSRX parse returned no program"))?;
+
+ if result.coordinate_domain == CoordinateDomain::OriginalUtf16Units {
+ rebase_utf16_spans(source, &mut tape).map_err(CompileError::parse)?;
+ }
+
+ project::project(source, filename, &tape, source_maps).map_err(|error| {
+ let (line, column) = line_column(source, error.start);
+ CompileError::parse(format!("{} ({line}:{column})", error.message))
+ })
+}
+
+/// Apply the post-reparse lazy/accessor rewrites to the projected program.
+pub fn apply_rewrites<'a>(
+ allocator: &'a oxc_allocator::Allocator,
+ program: &mut oxc_ast::ast::Program<'a>,
+ projection: &Projection,
+ source_maps: bool,
+) -> Result<(), CompileError> {
+ rewrite::apply(allocator, program, projection, source_maps).map_err(CompileError::transform)
+}
+
+/// Parse compiler-projected TSX with the exact runtime parser configuration.
+pub(crate) fn parse_projected_tsx<'a>(
+ allocator: &'a oxc_allocator::Allocator,
+ projection: &'a Projection,
+) -> Result, CompileError> {
+ let parsed = oxc_parser::Parser::new(allocator, &projection.text, oxc_span::SourceType::tsx())
+ .with_options(oxc_parser::ParseOptions {
+ preserve_parens: false,
+ ..oxc_parser::ParseOptions::default()
+ })
+ .parse();
+ if let Some(error) = crate::shared::parser::first_parser_error(parsed.diagnostics) {
+ return Err(CompileError::parse(error));
+ }
+ Ok(parsed.program)
+}
+
+/// Compose codegen's projected-TSX source map back to authored TSRX.
+pub fn compose_source_map(
+ intermediate: &oxc_sourcemap::SourceMap<'_>,
+ projection: &Projection,
+ authored_source: &str,
+ filename: &str,
+) -> String {
+ source_map::compose(
+ intermediate,
+ &projection.source_map,
+ &projection.text,
+ authored_source,
+ filename,
+ )
+}
+
+fn parse_source(
+ source: &str,
+ options: TsrxParseOptions<'_>,
+) -> Result {
+ if source.is_ascii() {
+ return parse_tsrx_with_options(&TsrxParseRequest { source }, options)
+ .map_err(|error| CompileError::parse(format!("TSRX parse failed: {error:?}")));
+ }
+ // The canonical route is ASCII-only; non-ASCII sources go through the
+ // exact-UTF-16 route and their spans are rebased to UTF-8 bytes below.
+ let units: Vec = source.encode_utf16().collect();
+ parse_tsrx_utf16_with_options(&TsrxUtf16ParseRequest { source: &units }, options)
+ .map_err(|error| CompileError::parse(format!("TSRX parse failed: {error:?}")))
+}
+
+/// Rewrite every `start`/`end` field in the tape from UTF-16 code units to
+/// UTF-8 byte offsets, so the projection can splice authored bytes directly.
+fn rebase_utf16_spans(source: &str, tape: &mut tsrx_tape_schema::FlatTape) -> Result<(), String> {
+ // Prefix table: UTF-16 unit index → UTF-8 byte offset.
+ let mut unit_to_byte: Vec = Vec::new();
+ for (byte_offset, ch) in source.char_indices() {
+ for _ in 0..ch.len_utf16() {
+ unit_to_byte.push(byte_offset as u32);
+ }
+ }
+ unit_to_byte.push(source.len() as u32);
+
+ let convert = |units: u32| -> Result {
+ unit_to_byte
+ .get(units as usize)
+ .copied()
+ .ok_or_else(|| format!("TSRX span offset {units} exceeds the source length"))
+ };
+
+ let object_count = tape.object_count() as u32;
+ for object in 0..object_count {
+ let object = RecordIndex::new(object);
+ for name in ["start", "end"] {
+ let Some(field) = tape.field_index(object, name) else {
+ continue;
+ };
+ let Some(value) = tape.field_value(field) else {
+ continue;
+ };
+ let Some(units) = tape.scalar_u32(value) else {
+ continue;
+ };
+ tape.set_field_value(field, ValueRef::inline_u32(convert(units)?))
+ .map_err(|error| error.to_string())?;
+ }
+ }
+ Ok(())
+}
+
+fn first_diagnostic_error(source: &str, result: &TsrxParseResult) -> CompileError {
+ let table = &result.errors;
+ let Some(record) = table.records().first() else {
+ return CompileError::parse("TSRX parse failed without diagnostics");
+ };
+ let message = table
+ .string(record.message)
+ .unwrap_or("TSRX parse failed")
+ .to_string();
+ let start = table
+ .labels(record.labels)
+ .and_then(|labels| {
+ labels
+ .iter()
+ .find(|label| label.primary)
+ .or_else(|| labels.first())
+ })
+ .map(|label| label.span.start);
+ match start {
+ Some(start) => {
+ // Failed parses report in the authored domain of the used route;
+ // for the UTF-16 route the offset is in code units, close enough
+ // for a line/column computed over chars.
+ let (line, column) = if result.coordinate_domain == CoordinateDomain::OriginalUtf16Units
+ {
+ line_column_utf16(source, start)
+ } else {
+ line_column(source, start)
+ };
+ CompileError::parse(format!("{message} ({line}:{column})"))
+ }
+ None => CompileError::parse(message),
+ }
+}
+
+/// 1-based line and 0-based column for a UTF-8 byte offset (ESTree `loc`
+/// convention, matching the Babel frontend's error suffix).
+fn line_column(source: &str, offset: u32) -> (u32, u32) {
+ let offset = (offset as usize).min(source.len());
+ let before = &source.as_bytes()[..offset];
+ let line = 1 + before.iter().filter(|byte| **byte == b'\n').count() as u32;
+ let line_start = before
+ .iter()
+ .rposition(|byte| *byte == b'\n')
+ .map(|position| position + 1)
+ .unwrap_or(0);
+ let column = source[line_start..offset].encode_utf16().count() as u32;
+ (line, column)
+}
+
+fn line_column_utf16(source: &str, offset_units: u32) -> (u32, u32) {
+ let mut units = 0u32;
+ for (byte_offset, ch) in source.char_indices() {
+ if units >= offset_units {
+ return line_column(source, byte_offset as u32);
+ }
+ units += ch.len_utf16() as u32;
+ }
+ line_column(source, source.len() as u32)
+}
diff --git a/packages/compiler/src/tsrx/names.rs b/packages/compiler/src/tsrx/names.rs
new file mode 100644
index 000000000..c6fe47835
--- /dev/null
+++ b/packages/compiler/src/tsrx/names.rs
@@ -0,0 +1,42 @@
+use std::collections::{HashMap, HashSet};
+
+use oxc_semantic::Semantic;
+
+#[derive(Default)]
+pub(super) struct Names {
+ used: HashSet,
+ next: HashMap<&'static str, u32>,
+}
+
+impl Names {
+ pub fn from_semantic(semantic: &Semantic<'_>) -> Self {
+ let mut names = Self::default();
+ for node in semantic.nodes() {
+ match node.kind() {
+ oxc_ast::AstKind::BindingIdentifier(ident) => {
+ names.used.insert(ident.name.to_string());
+ }
+ oxc_ast::AstKind::IdentifierReference(ident) => {
+ names.used.insert(ident.name.to_string());
+ }
+ oxc_ast::AstKind::JSXIdentifier(ident) => {
+ names.used.insert(ident.name.to_string());
+ }
+ _ => {}
+ }
+ }
+ names
+ }
+
+ pub fn allocate(&mut self, prefix: &'static str) -> String {
+ let mut index = *self.next.get(prefix).unwrap_or(&0);
+ loop {
+ let name = format!("{prefix}{index}");
+ index += 1;
+ if self.used.insert(name.clone()) {
+ self.next.insert(prefix, index);
+ return name;
+ }
+ }
+ }
+}
diff --git a/packages/compiler/src/tsrx/project.rs b/packages/compiler/src/tsrx/project.rs
new file mode 100644
index 000000000..f65cd6825
--- /dev/null
+++ b/packages/compiler/src/tsrx/project.rs
@@ -0,0 +1,1780 @@
+//! TSRX → Solid JSX desugaring, as authored-text projection.
+//!
+//! Mirrors `@solidjs/babel-plugin`'s `src/tsrx/desugar.ts` (the frozen
+//! contract) construct-for-construct, but in the text domain: typed nodes from
+//! [`super::semantic`] identify Solid semantics and each construct extent is
+//! replaced with the desugared Solid-JSX source form. Authored bytes outside
+//! constructs are copied verbatim. The projected text reparses with the
+//! crate's own oxc and produces the same AST the Babel frontend hands its
+//! pipeline — generated parentheses are trivia (`preserve_parens: false`)
+//! and generated JSX carries no stray whitespace children.
+//!
+//! Lazy `&` patterns are only *stripped* here (each pattern keeps its
+//! authored binding names, so the reparsed program has real,
+//! scope-resolvable bindings); the `__lazyN` renames and accessor-call
+//! rewrites happen after the reparse in [`crate::tsrx::rewrite`], driven by
+//! the anchors recorded in [`Projection`].
+//!
+//! Emission is strictly append-only (no detached buffers), so anchor offsets
+//! are final as they are recorded. Where output order differs from authored
+//! order (a `@switch` `@default` case becomes the leading `fallback`
+//! attribute), blocks are validated in the Babel frontend's order first and
+//! re-analyzed cheaply during emission.
+
+use super::{
+ semantic::{
+ self, CatchBinding, CodeBlock, ControlFlow, ForLoop, IfChain, Switch as SemanticSwitch,
+ SwitchArm, Try as SemanticTry,
+ },
+ source_map::ProjectionMap,
+ style_projection::{
+ self, RefSetup, StyleAction, StyleProjection, class_attribute, decode_json_string,
+ is_callback_ref, is_class_attribute, is_direct_ref_target, push_class_map, push_js_string,
+ },
+ tape::{self, Node},
+};
+
+/// Result of projecting one TSRX module to plain TSX.
+pub struct Projection {
+ pub text: String,
+ /// Concatenated extracted stylesheets in owner-visitor order.
+ pub css: String,
+ /// Space-separated scope hashes, or `None` when no styles were present.
+ pub css_hash: Option,
+ /// Parser-authored embedded CSS and raw-text script bodies.
+ pub(super) embedded_regions: Vec,
+ /// Exact authored ranges copied into `text`, used to compose codegen maps.
+ pub(super) source_map: ProjectionMap,
+ /// Projected offset of each lazy pattern's opening bracket, with its
+ /// preallocated `__lazyN` name.
+ pub lazy_patterns: Vec<(u32, String, bool)>,
+ /// Projected offset of a generated arrow (its parameter `(`), with the
+ /// binding names whose reads must become zero-argument calls (RC accessor
+ /// semantics for non-default `For` items, custom-key `For` indexes, and
+ /// `@catch` errors).
+ pub accessor_arrows: Vec<(u32, Vec)>,
+}
+
+/// A structured frontend diagnostic in authored coordinates.
+pub struct ProjectError {
+ pub message: String,
+ /// Authored byte offset the diagnostic points at.
+ pub start: u32,
+}
+
+impl ProjectError {
+ fn new(message: impl Into, node: Node<'_>) -> Self {
+ Self {
+ message: message.into(),
+ start: node.span().map(|(start, _)| start).unwrap_or(0),
+ }
+ }
+}
+
+type Result = std::result::Result;
+
+/// Whether a rendered expression is structurally JSX (usable as a bare JSX
+/// child) or needs an expression container.
+#[derive(Clone, Copy, PartialEq)]
+enum Shape {
+ Jsx,
+ Expr,
+}
+
+/// Where a node sits, which decides its rendered form.
+#[derive(Clone, Copy, PartialEq)]
+enum Position {
+ /// The `@{}` body of a function: statements plus `return render;`.
+ FunctionBody,
+ /// Expression slot (arrow body, attribute container, argument, …).
+ Expression,
+ /// JSX child slot: non-JSX results need `{…}` wrapping.
+ JsxChild,
+}
+
+const FUNCTION_TYPES: [&str; 3] = [
+ "FunctionDeclaration",
+ "FunctionExpression",
+ "ArrowFunctionExpression",
+];
+
+const RENDER_ENTRY_TYPES: [&str; 9] = [
+ "JSXElement",
+ "JSXFragment",
+ "JSXText",
+ "JSXCodeBlock",
+ "JSXIfExpression",
+ "JSXForExpression",
+ "JSXSwitchExpression",
+ "JSXTryExpression",
+ "JSXStyleElement",
+];
+
+const LOOP_TYPES: [&str; 5] = [
+ "ForStatement",
+ "ForInStatement",
+ "ForOfStatement",
+ "WhileStatement",
+ "DoWhileStatement",
+];
+
+/// TSRX constructs are validation boundaries: their blocks are checked when
+/// they desugar, with their own construct label.
+const ESCAPE_BOUNDARY_TYPES: [&str; 5] = [
+ "JSXCodeBlock",
+ "JSXIfExpression",
+ "JSXForExpression",
+ "JSXSwitchExpression",
+ "JSXTryExpression",
+];
+
+fn is_function(ty: &str) -> bool {
+ FUNCTION_TYPES.contains(&ty)
+}
+
+fn is_render_entry(ty: &str) -> bool {
+ RENDER_ENTRY_TYPES.contains(&ty)
+}
+
+fn is_lazy_pattern(node: Node<'_>) -> bool {
+ matches!(node.ty(), "ArrayPattern" | "ObjectPattern") && node.bool_field("lazy")
+}
+
+fn lazy_assignment_pattern(node: Node<'_>) -> Option> {
+ if node.ty() != "ExpressionStatement" {
+ return None;
+ }
+ let expression = node.node_field("expression")?;
+ if expression.ty() != "AssignmentExpression" || expression.str_field("operator") != Some("=") {
+ return None;
+ }
+ expression
+ .node_field("left")
+ .filter(|pattern| is_lazy_pattern(*pattern))
+}
+
+fn contains_lazy_pattern(node: Node<'_>) -> bool {
+ let mut found = false;
+ tape::walk(node, &mut |child| {
+ if is_lazy_pattern(child) {
+ found = true;
+ return false;
+ }
+ true
+ });
+ found
+}
+
+fn contains_pattern_default(node: Node<'_>) -> bool {
+ let mut found = false;
+ tape::walk(node, &mut |child| {
+ if child.ty() == "AssignmentPattern" {
+ found = true;
+ return false;
+ }
+ true
+ });
+ found
+}
+
+fn exported_lazy_declaration(root: Node<'_>) -> Option> {
+ let mut invalid = None;
+ tape::walk(root, &mut |node| {
+ if matches!(
+ node.ty(),
+ "ExportNamedDeclaration" | "ExportDefaultDeclaration"
+ ) && let Some(declaration) = node.node_field("declaration")
+ && declaration.ty() == "VariableDeclaration"
+ && declaration
+ .list_field("declarations")
+ .flatten()
+ .any(|declarator| {
+ declarator
+ .node_field("id")
+ .is_some_and(contains_lazy_pattern)
+ })
+ {
+ invalid = Some(declaration);
+ return false;
+ }
+ invalid.is_none()
+ });
+ invalid
+}
+
+pub fn project(
+ source: &str,
+ filename: &str,
+ tape: &tsrx_tape_schema::FlatTape,
+ source_maps: bool,
+) -> Result {
+ let root = Node::root(tape).ok_or(ProjectError {
+ message: "TSRX parse produced no program".into(),
+ start: 0,
+ })?;
+ if let Some(declaration) = exported_lazy_declaration(root) {
+ return Err(ProjectError::new(
+ "TSRX lazy bindings cannot be exported",
+ declaration,
+ ));
+ }
+
+ let semantic = semantic::lower(root).map_err(|error| ProjectError {
+ message: error.message,
+ start: error.start,
+ })?;
+ let styles = style_projection::plan(source, filename, &semantic)?;
+ let css = styles.css.clone();
+ let css_hash = styles.css_hash.clone();
+ let embedded_regions = semantic.embedded_regions.clone();
+ let mut renderer = Renderer {
+ source,
+ out: String::with_capacity(source.len() + source.len() / 4),
+ semantic: &semantic,
+ styles,
+ lazy_ids: collect_lazy_ids(root, &semantic),
+ lazy_patterns: Vec::new(),
+ accessor_arrows: Vec::new(),
+ suppress_nested_lazy: 0,
+ source_map: ProjectionMap::new(source_maps),
+ };
+
+ renderer.emit_verbatim_with_specials(root, 0, source.len() as u32, Position::Expression)?;
+
+ Ok(Projection {
+ text: renderer.out,
+ css,
+ css_hash,
+ embedded_regions,
+ source_map: renderer.source_map,
+ lazy_patterns: renderer.lazy_patterns,
+ accessor_arrows: renderer.accessor_arrows,
+ })
+}
+
+/// Preallocate `__lazyN` names for every lazy pattern in document order,
+/// mirroring `@tsrx/core`'s `preallocateLazyIds`. Keyed by pattern span.
+fn collect_lazy_ids(root: Node<'_>, semantic: &semantic::SolidTsrxModule<'_>) -> Vec<(u32, u32)> {
+ let mut spans: Vec<(u32, u32)> = Vec::new();
+ tape::walk(root, &mut |node| {
+ match node.ty() {
+ "VariableDeclarator" => {
+ if let Some(pattern) = node.node_field("id") {
+ collect_topmost_lazy_patterns(pattern, &mut spans);
+ }
+ }
+ "FunctionDeclaration" | "FunctionExpression" | "ArrowFunctionExpression" => {
+ for pattern in node.list_field("params").flatten() {
+ collect_topmost_lazy_patterns(pattern, &mut spans);
+ }
+ }
+ "CatchClause" => {
+ if let Some(pattern) = node.node_field("param") {
+ collect_topmost_lazy_patterns(pattern, &mut spans);
+ }
+ }
+ "ExpressionStatement" => {
+ if let Some(pattern) = lazy_assignment_pattern(node) {
+ collect_topmost_lazy_patterns(pattern, &mut spans);
+ }
+ }
+ _ => {}
+ }
+ true
+ });
+ for control in &semantic.control_flow {
+ let pattern = match control {
+ ControlFlow::For(loop_) if loop_.callback_mode.item_is_accessor() => {
+ Some(loop_.pattern)
+ }
+ ControlFlow::Try(try_) => try_.catch.as_ref().and_then(|catch| match catch.binding {
+ Some(CatchBinding::Pattern(pattern)) => Some(pattern),
+ _ => None,
+ }),
+ _ => None,
+ };
+ if let Some(pattern) = pattern
+ && pattern.ty() != "Identifier"
+ && let Some(span) = pattern.span()
+ {
+ spans.push(span);
+ }
+ }
+ spans.sort_unstable();
+ spans.dedup();
+ spans
+}
+
+fn collect_topmost_lazy_patterns(node: Node<'_>, spans: &mut Vec<(u32, u32)>) {
+ match node.ty() {
+ "AssignmentPattern" => {
+ if let Some(left) = node.node_field("left") {
+ collect_topmost_lazy_patterns(left, spans);
+ }
+ }
+ "RestElement" => {
+ if let Some(argument) = node.node_field("argument") {
+ collect_topmost_lazy_patterns(argument, spans);
+ }
+ }
+ "ObjectPattern" | "ArrayPattern" if is_lazy_pattern(node) => {
+ if let Some(span) = node.span() {
+ spans.push(span);
+ }
+ }
+ "ObjectPattern" => {
+ for property in node.list_field("properties").flatten() {
+ let child = if property.ty() == "RestElement" {
+ property.node_field("argument")
+ } else {
+ property.node_field("value")
+ };
+ if let Some(child) = child {
+ collect_topmost_lazy_patterns(child, spans);
+ }
+ }
+ }
+ "ArrayPattern" => {
+ for element in node.list_field("elements").flatten() {
+ collect_topmost_lazy_patterns(element, spans);
+ }
+ if let Some(rest) = node.node_field("rest") {
+ collect_topmost_lazy_patterns(rest, spans);
+ }
+ }
+ _ => {}
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Special-node collection (for verbatim regions)
+// ---------------------------------------------------------------------------
+
+struct Special<'t> {
+ node: Node<'t>,
+ /// Replacement span in authored bytes (differs from the node span only
+ /// for lazy patterns, which also consume the preceding `&` sigil).
+ span: (u32, u32),
+ position: Position,
+}
+
+/// Find the outermost nodes within `node`'s subtree that need re-rendering,
+/// in document order. Does not descend into found specials: their renderers
+/// re-collect within themselves. `position` classifies `node` itself when it
+/// is special.
+fn collect_specials<'t>(
+ node: Node<'t>,
+ position: Position,
+ styles: &StyleProjection<'t>,
+ semantic: &semantic::SolidTsrxModule<'t>,
+ out: &mut Vec>,
+) {
+ let ty = node.ty();
+ let start = node.span().map_or(u32::MAX, |span| span.0);
+
+ let special_span = if lazy_assignment_pattern(node).is_some() {
+ node.span()
+ } else if let Some(control) = semantic.control_for(node) {
+ let extent = control.origin().extent;
+ Some((extent.start, extent.end))
+ } else if ty == "JSXCodeBlock"
+ || ty == "JSXStyleElement"
+ || semantic.raw_text_script_for(node).is_some()
+ || tape::is_dynamic_element(node)
+ || (ty == "JSXElement"
+ && (styles.element_hashes.contains_key(&start)
+ || styles.owner_setups.contains_key(&start)))
+ || (ty == "JSXFragment" && styles.owner_setups.contains_key(&start))
+ || (ty == "JSXAttribute" && node.bool_field("shorthand"))
+ {
+ node.span()
+ } else if is_lazy_pattern(node) {
+ // The `&` sigil sits immediately before the pattern's bracket.
+ node.span()
+ .map(|(start, end)| (start.saturating_sub(1), end))
+ } else {
+ None
+ };
+
+ if let Some(span) = special_span {
+ out.push(Special {
+ node,
+ span,
+ position,
+ });
+ return;
+ }
+
+ collect_children(node, styles, semantic, out);
+}
+
+fn collect_children<'t>(
+ node: Node<'t>,
+ styles: &StyleProjection<'t>,
+ semantic: &semantic::SolidTsrxModule<'t>,
+ out: &mut Vec>,
+) {
+ let ty = node.ty();
+ for (key, value) in node.fields() {
+ if matches!(key, "type" | "start" | "end" | "metadata" | "loc" | "range") {
+ continue;
+ }
+ let child_position = match (ty, key) {
+ (parent, "body") if is_function(parent) => Position::FunctionBody,
+ ("JSXElement" | "JSXFragment", "children") => Position::JsxChild,
+ _ => Position::Expression,
+ };
+ match value.kind() {
+ tsrx_tape_schema::ValueKind::Object => {
+ if let Some(child) = Node::from_value(node.tape(), value) {
+ collect_specials(child, child_position, styles, semantic, out);
+ }
+ }
+ tsrx_tape_schema::ValueKind::List => {
+ if let Some(list) = value.as_list() {
+ let mut next = node.tape().list_first_value(list);
+ while let Some(entry) = next.filter(|entry| !entry.is_none()) {
+ if let Some(item) = node.tape().list_value(entry)
+ && let Some(child) = Node::from_value(node.tape(), item)
+ {
+ collect_specials(child, child_position, styles, semantic, out);
+ }
+ next = node.tape().list_value_next(entry);
+ }
+ }
+ }
+ _ => {}
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Shape prediction (decides `{…}` wrapping before any text is emitted)
+// ---------------------------------------------------------------------------
+
+/// Shape of one render entry once lowered to an expression.
+fn predict_entry_shape(node: Node<'_>) -> Shape {
+ match node.ty() {
+ "JSXElement" | "JSXFragment" | "JSXStyleElement" => Shape::Jsx,
+ "JSXText" => Shape::Expr,
+ "JSXIfExpression" | "JSXForExpression" | "JSXSwitchExpression" => Shape::Jsx,
+ "JSXTryExpression" => predict_try_shape(node),
+ "JSXCodeBlock" => {
+ if node.list_field("body").next().is_some() {
+ Shape::Expr
+ } else {
+ node.node_field("render")
+ .map(predict_entry_shape)
+ .unwrap_or(Shape::Expr)
+ }
+ }
+ _ => Shape::Expr,
+ }
+}
+
+fn predict_try_shape(node: Node<'_>) -> Shape {
+ if node.has_node_field("handler") || node.has_node_field("pending") {
+ return Shape::Jsx;
+ }
+ node.node_field("block")
+ .map(|block| predict_block_shape(block))
+ .unwrap_or(Shape::Expr)
+}
+
+/// Shape of a whole template block lowered to an expression (ignoring the
+/// empty case, which callers reject or omit before wrapping decisions).
+fn predict_block_shape(block: Node<'_>) -> Shape {
+ let (setup, renders) = partition_entries(&block_entries(block));
+ if !setup.is_empty() {
+ return Shape::Expr;
+ }
+ match renders.as_slice() {
+ [only] => predict_entry_shape(*only),
+ [] => Shape::Expr,
+ _ => Shape::Jsx,
+ }
+}
+
+fn block_entries<'t>(block: Node<'t>) -> Vec> {
+ if block.ty() == "BlockStatement" {
+ block.list_field("body").flatten().collect()
+ } else {
+ vec![block]
+ }
+}
+
+/// Split entries into setup statements and render outputs, skipping
+/// whitespace-only JSXText. Pure analysis; ordering errors surface in
+/// [`Renderer::block_parts_of_entries`].
+fn partition_entries<'t>(entries: &[Node<'t>]) -> (Vec>, Vec>) {
+ let mut setup = Vec::new();
+ let mut renders = Vec::new();
+ for entry in entries {
+ if is_render_entry(entry.ty()) {
+ if entry.ty() == "JSXText" && entry.str_field("value").is_some_and(decode_json_ws_only)
+ {
+ continue;
+ }
+ renders.push(*entry);
+ } else if renders.is_empty() {
+ setup.push(*entry);
+ }
+ }
+ (setup, renders)
+}
+
+/// Whether a template block lowers to nothing (fully empty block).
+fn block_is_empty(block: Node<'_>) -> bool {
+ let (setup, renders) = partition_entries(&block_entries(block));
+ setup.is_empty() && renders.is_empty()
+}
+
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+
+struct BlockParts<'t> {
+ setup: Vec>,
+ renders: Vec>,
+}
+
+struct Renderer<'s, 'm, 't> {
+ source: &'s str,
+ out: String,
+ semantic: &'m semantic::SolidTsrxModule<'t>,
+ styles: StyleProjection<'t>,
+ /// Document-ordered lazy pattern spans; index = lazy id.
+ lazy_ids: Vec<(u32, u32)>,
+ lazy_patterns: Vec<(u32, String, bool)>,
+ accessor_arrows: Vec<(u32, Vec)>,
+ suppress_nested_lazy: usize,
+ source_map: ProjectionMap,
+}
+
+impl<'s, 'm, 't> Renderer<'s, 'm, 't> {
+ fn push_verbatim(&mut self, start: u32, end: u32) {
+ if end <= start {
+ return;
+ }
+ self.source_map
+ .record_verbatim(self.out.len() as u32, start, end);
+ self.out
+ .push_str(&self.source[start as usize..end as usize]);
+ }
+
+ fn push(&mut self, text: &str) {
+ self.out.push_str(text);
+ }
+
+ /// Emit `[start, end)` of authored source, re-rendering the specials
+ /// found within `scope`'s subtree.
+ fn emit_verbatim_with_specials(
+ &mut self,
+ scope: Node<'_>,
+ start: u32,
+ end: u32,
+ position: Position,
+ ) -> Result<()> {
+ let mut specials = Vec::new();
+ collect_specials(scope, position, &self.styles, self.semantic, &mut specials);
+ self.emit_region(start, end, &mut specials)
+ }
+
+ /// Emit an authored region, splicing in the specials whose replacement
+ /// span lies within `[start, end)`.
+ fn emit_region(&mut self, start: u32, end: u32, specials: &mut Vec>) -> Result<()> {
+ // Tape field order is not source order (e.g. `children` can precede
+ // `openingElement`): splice in document order.
+ specials.sort_by_key(|special| special.span.0);
+ let mut cursor = start;
+ for special in specials.iter() {
+ let (s_start, s_end) = special.span;
+ if s_start < cursor || s_end > end {
+ continue;
+ }
+ self.push_verbatim(cursor, s_start);
+ self.render_special(special.node, special.position)?;
+ cursor = s_end;
+ }
+ self.push_verbatim(cursor, end);
+ Ok(())
+ }
+
+ /// Emit one authored node in the given position: dispatches specials
+ /// directly, copies everything else verbatim with nested specials.
+ fn emit_node(&mut self, node: Node<'_>, position: Position) -> Result<()> {
+ let ty = node.ty();
+ let start = node.span().map_or(u32::MAX, |span| span.0);
+ if self.semantic.control_for(node).is_some()
+ || ty == "JSXStyleElement"
+ || self.semantic.raw_text_script_for(node).is_some()
+ || tape::is_dynamic_element(node)
+ || (ty == "JSXElement"
+ && (self.styles.element_hashes.contains_key(&start)
+ || self.styles.owner_setups.contains_key(&start)))
+ || (ty == "JSXFragment" && self.styles.owner_setups.contains_key(&start))
+ || (ty == "JSXAttribute" && node.bool_field("shorthand"))
+ || lazy_assignment_pattern(node).is_some()
+ || is_lazy_pattern(node)
+ {
+ return self.render_special(node, position);
+ }
+ let (start, end) = span_of(node)?;
+ let mut specials = Vec::new();
+ collect_children(node, &self.styles, self.semantic, &mut specials);
+ self.emit_region(start, end, &mut specials)
+ }
+
+ fn render_special(&mut self, node: Node<'_>, position: Position) -> Result<()> {
+ if let Some(control) = self.semantic.control_for(node) {
+ return match control {
+ ControlFlow::CodeBlock(code) => self.render_code_block(code, position),
+ ControlFlow::If(chain) => self.render_if(chain),
+ ControlFlow::For(loop_) => self.render_for(loop_),
+ ControlFlow::Switch(switch) => self.render_switch(switch),
+ ControlFlow::Try(try_) => self.render_try(try_, position),
+ };
+ }
+ match node.ty() {
+ "JSXStyleElement" => self.render_style(node),
+ "JSXFragment" => self.render_scoped_fragment(node, position),
+ "JSXAttribute" => self.render_shorthand_attr(node),
+ "JSXElement" if self.semantic.raw_text_script_for(node).is_some() => {
+ self.render_raw_text_script(node, position)
+ }
+ "JSXElement" => self.render_scoped_element(node, position),
+ "ExpressionStatement" if lazy_assignment_pattern(node).is_some() => {
+ self.render_lazy_assignment(node)
+ }
+ "ArrayPattern" | "ObjectPattern" if self.suppress_nested_lazy > 0 => {
+ self.emit_eager_pattern(node)
+ }
+ "ArrayPattern" | "ObjectPattern" => self.render_lazy_pattern(node),
+ other => Err(ProjectError::new(
+ format!("Unsupported TSRX construct `{other}`"),
+ node,
+ )),
+ }
+ }
+
+ // -- @{} statement containers ---------------------------------------------
+
+ fn render_code_block(&mut self, code: &CodeBlock<'t>, position: Position) -> Result<()> {
+ let node = code.origin.tape;
+ let render = code.render;
+ let setup = &code.setup;
+ let style_setups = self
+ .styles
+ .owner_setups
+ .get(&span_of(node)?.0)
+ .cloned()
+ .unwrap_or_default();
+
+ match position {
+ Position::FunctionBody => {
+ self.push("{\n");
+ self.emit_statements(setup)?;
+ for setup in &style_setups {
+ self.emit_ref_setup(setup)?;
+ }
+ self.push("return ");
+ self.render_entry_expression(render)?;
+ self.push(";\n}");
+ }
+ Position::Expression | Position::JsxChild => {
+ let wrap = position == Position::JsxChild
+ && (if setup.is_empty() && style_setups.is_empty() {
+ predict_entry_shape(render) == Shape::Expr
+ } else {
+ true
+ });
+ if wrap {
+ self.push("{");
+ }
+ if setup.is_empty() && style_setups.is_empty() {
+ self.render_entry_expression(render)?;
+ } else {
+ self.push("(() => {\n");
+ self.emit_statements(setup)?;
+ for setup in &style_setups {
+ self.emit_ref_setup(setup)?;
+ }
+ self.push("return ");
+ self.render_entry_expression(render)?;
+ self.push(";\n})()");
+ }
+ if wrap {
+ self.push("}");
+ }
+ }
+ }
+ Ok(())
+ }
+
+ // -- @if — Show / Switch+Match ---------------------------------------------
+
+ fn render_if(&mut self, chain: &IfChain<'t>) -> Result<()> {
+ // Validate in the Babel frontend's order: @else first, then branches.
+ if let Some(fallback) = &chain.fallback {
+ self.block_parts(fallback.node, Some("@else"))?;
+ }
+ for branch in &chain.branches {
+ self.block_parts(branch.body.node, Some("@if"))?;
+ }
+
+ let has_fallback = chain
+ .fallback
+ .as_ref()
+ .is_some_and(|fallback| !block_is_empty(fallback.node));
+
+ if let [branch] = chain.branches.as_slice() {
+ self.push("");
+ }
+
+ self.push("");
+ for branch in &chain.branches {
+ self.push("")?;
+ }
+ self.push("");
+ Ok(())
+ }
+
+ /// Emit a construct's block as its JSX children (or self-close when the
+ /// block renders nothing), then the closing tag.
+ fn emit_construct_children(
+ &mut self,
+ block: Node<'_>,
+ construct: &str,
+ closing: &str,
+ ) -> Result<()> {
+ if block_is_empty(block) {
+ self.push("/>");
+ return Ok(());
+ }
+ self.push(">");
+ let shape = predict_block_shape(block);
+ if shape == Shape::Jsx {
+ self.emit_block_expression(block, construct)?;
+ } else {
+ self.push("{");
+ self.emit_block_expression(block, construct)?;
+ self.push("}");
+ }
+ self.push(closing);
+ Ok(())
+ }
+
+ // -- @for — For --------------------------------------------------------------
+
+ fn render_for(&mut self, loop_: &ForLoop<'t>) -> Result<()> {
+ let node = loop_.origin.tape;
+ let pattern = loop_.pattern;
+ let each = loop_.iterable;
+ let index = loop_.index;
+ let key = loop_.key;
+ let mode = loop_.callback_mode;
+ let body = loop_.body.node;
+ // Validate the body before attribute emission (Babel order); reject a
+ // renderless body up front.
+ let parts = self.block_parts(body, Some("@for"))?;
+ if parts.renders.is_empty() {
+ return Err(ProjectError::new(
+ "A TSRX @for body must end with rendered output",
+ node,
+ ));
+ }
+
+ self.push(" (");
+ self.emit_node(key, Position::Expression)?;
+ self.push(")}");
+ } else if mode.emits_non_keyed_intent() {
+ self.push(" keyed={false}");
+ }
+ if let Some(empty) = &loop_.empty {
+ let empty = empty.node;
+ if !block_is_empty(empty) {
+ self.push(" fallback={");
+ self.emit_block_expression(empty, "@empty")?;
+ self.push("}");
+ } else {
+ // Still validate the empty block (escape rules apply).
+ self.block_parts(empty, Some("@empty"))?;
+ }
+ }
+ self.push(">{");
+
+ // RC `For` callback shape:
+ // - default keyed mode: raw item, accessor index (there is no TSRX index)
+ // - keyed={false}: accessor item, raw index
+ // - custom key: accessor item, accessor index
+ // The post-reparse pass rewrites accessor reads at this arrow.
+ let mut accessor_names = Vec::new();
+ if mode.item_is_accessor()
+ && let Some(name) = ident_name(pattern)
+ {
+ accessor_names.push(name.to_string());
+ }
+ if mode.index_is_accessor()
+ && let Some(index) = index
+ && let Some(name) = ident_name(index)
+ {
+ accessor_names.push(name.to_string());
+ }
+ if !accessor_names.is_empty() {
+ self.accessor_arrows
+ .push((self.out.len() as u32, accessor_names));
+ }
+
+ self.push("(");
+ if mode.item_is_accessor() && pattern.ty() != "Identifier" {
+ self.render_lazy_pattern_with_source(pattern, true)?;
+ } else {
+ self.emit_node(pattern, Position::Expression)?;
+ }
+ if let Some(index) = index {
+ self.push(", ");
+ self.emit_node(index, Position::Expression)?;
+ }
+ self.push(") => ");
+ if parts.setup.is_empty() {
+ self.push("(");
+ self.emit_renders_expression(&parts.renders)?;
+ self.push(")");
+ } else {
+ self.push("{\n");
+ self.emit_statements(&parts.setup)?;
+ self.push("return ");
+ self.emit_renders_expression(&parts.renders)?;
+ self.push(";\n}");
+ }
+ self.push("}");
+ Ok(())
+ }
+
+ // -- @switch — Switch / Match --------------------------------------------------
+
+ fn render_switch(&mut self, switch: &SemanticSwitch<'t>) -> Result<()> {
+ // Validate every case in authored order first (the @default case is
+ // emitted out of order, as the leading `fallback` attribute).
+ for arm in &switch.arms {
+ let label = match arm {
+ SwitchArm::Case { .. } => "@case",
+ SwitchArm::Default { .. } => "@default",
+ };
+ let parts = self.block_parts_of_entries(arm.entries(), Some(label))?;
+ if !parts.setup.is_empty() && parts.renders.is_empty() {
+ return Err(ProjectError::new(
+ "A TSRX @case block with setup statements must end with rendered output",
+ arm.origin().tape,
+ ));
+ }
+ }
+
+ let default_arm = switch.default_arm();
+ let has_fallback = default_arm.is_some_and(|arm| {
+ let (setup, renders) = partition_entries(arm.entries());
+ !(setup.is_empty() && renders.is_empty())
+ });
+
+ self.push("");
+ for arm in &switch.arms {
+ let SwitchArm::Case { test, entries, .. } = arm else {
+ continue;
+ };
+ self.push("");
+ continue;
+ }
+ self.push(">");
+ let shape = if setup.is_empty() {
+ match renders.as_slice() {
+ [only] => predict_entry_shape(*only),
+ _ => Shape::Jsx,
+ }
+ } else {
+ Shape::Expr
+ };
+ if shape == Shape::Jsx {
+ self.emit_case_expression(entries, "@case")?;
+ } else {
+ self.push("{");
+ self.emit_case_expression(entries, "@case")?;
+ self.push("}");
+ }
+ self.push("");
+ }
+ self.push("");
+ Ok(())
+ }
+
+ fn emit_case_expression(&mut self, entries: &[Node<'_>], label: &str) -> Result<()> {
+ let parts = self.block_parts_of_entries(entries, Some(label))?;
+ self.emit_parts_expression(&parts)
+ }
+
+ // -- @try / @pending / @catch — Errored / Loading -------------------------------
+
+ fn render_try(&mut self, try_: &SemanticTry<'t>, position: Position) -> Result<()> {
+ let node = try_.origin.tape;
+ let block = try_.body.node;
+ // Validate in the Babel frontend's order: @try, then @pending, then
+ // @catch — output order is the reverse nesting.
+ let content_parts = self.block_parts(block, Some("@try"))?;
+ if content_parts.renders.is_empty() {
+ // Setup-only blocks get blockToExpression's message; fully empty
+ // ones get the @try-specific message, matching the Babel frontend.
+ return Err(if content_parts.setup.is_empty() {
+ ProjectError::new("A TSRX @try block must end with rendered output", node)
+ } else {
+ ProjectError::new(
+ "A TSRX @try block with setup statements must end with rendered output",
+ block,
+ )
+ });
+ }
+ let pending = try_.pending.as_ref().map(|pending| pending.node);
+ if let Some(pending) = pending {
+ self.block_parts(pending, Some("@pending"))?;
+ }
+ let handler = try_.catch.as_ref();
+ let mut error_name = String::from("_e");
+ let mut reset_name: Option = None;
+ let mut has_error_param = false;
+ let mut error_pattern = None;
+ if let Some(handler) = handler {
+ if let Some(binding) = &handler.binding {
+ match binding {
+ CatchBinding::Identifier { name, .. } => {
+ error_name = (*name).to_string();
+ has_error_param = true;
+ }
+ CatchBinding::Pattern(pattern) => error_pattern = Some(*pattern),
+ }
+ }
+ if let Some(reset) = handler.reset.and_then(ident_name) {
+ reset_name = Some(reset.to_string());
+ }
+ let handler_body = handler.body.node;
+ let handler_parts = self.block_parts(handler_body, Some("@catch"))?;
+ if handler_parts.renders.is_empty() {
+ return Err(if handler_parts.setup.is_empty() {
+ ProjectError::new(
+ "A TSRX @catch block must end with rendered output",
+ handler.origin.tape,
+ )
+ } else {
+ ProjectError::new(
+ "A TSRX @catch block with setup statements must end with rendered output",
+ handler_body,
+ )
+ });
+ }
+ }
+
+ let inner_shape = if pending.is_some() {
+ Shape::Jsx
+ } else {
+ predict_block_shape(block)
+ };
+ let result_shape = if handler.is_some() {
+ Shape::Jsx
+ } else {
+ inner_shape
+ };
+
+ let wrap = position == Position::JsxChild && result_shape != Shape::Jsx;
+ if wrap {
+ self.push("{");
+ }
+
+ if let Some(handler) = handler {
+ self.push(" (");
+ self.emit_block_expression(handler.body.node, "@catch")?;
+ self.push(")}>");
+ }
+
+ if let Some(pending) = pending {
+ self.push("");
+ let content_shape = predict_block_shape(block);
+ if content_shape == Shape::Jsx {
+ self.emit_block_expression(block, "@try")?;
+ } else {
+ self.push("{");
+ self.emit_block_expression(block, "@try")?;
+ self.push("}");
+ }
+ self.push("");
+ } else if handler.is_some() {
+ let content_shape = predict_block_shape(block);
+ if content_shape == Shape::Jsx {
+ self.emit_block_expression(block, "@try")?;
+ } else {
+ self.push("{");
+ self.emit_block_expression(block, "@try")?;
+ self.push("}");
+ }
+ } else {
+ self.emit_block_expression(block, "@try")?;
+ }
+
+ if handler.is_some() {
+ self.push("");
+ }
+ if wrap {
+ self.push("}");
+ }
+ Ok(())
+ }
+
+ // -- Dynamic tags and shorthand props -----------------------------------------
+
+ fn render_style(&mut self, node: Node<'_>) -> Result<()> {
+ let start = span_of(node)?.0;
+ match self.styles.actions.get(&start).cloned() {
+ Some(StyleAction::Remove) => Ok(()),
+ Some(StyleAction::ClassMap(entries)) => {
+ push_class_map(&mut self.out, &entries);
+ Ok(())
+ }
+ Some(StyleAction::EmptyElement) => {
+ let opening = node.node_field("openingElement").ok_or_else(|| {
+ ProjectError::new("A TSRX \n\
+ }";
+ let tape = parse(source);
+ let module = lower(Node::root(&tape).unwrap()).expect("semantic IR");
+ let script = module.raw_text_scripts.first().expect("raw script");
+ assert_eq!(
+ &source[script.payload.start as usize..script.payload.end as usize],
+ "{\"ok\":true}"
+ );
+ assert_eq!(
+ module
+ .raw_text_script_for(script.origin.tape)
+ .map(|script| script.payload),
+ Some(script.payload)
+ );
+ assert_eq!(
+ module
+ .embedded_regions
+ .iter()
+ .map(|region| region.kind)
+ .collect::>(),
+ [EmbeddedKind::Css, EmbeddedKind::Script]
+ );
+ }
+
+ #[test]
+ fn lowers_if_chain_and_fallback() {
+ let source = "export const C = ({ a, b }) => @if (a) { } @else if (b) { } @else { };";
+ let tape = parse(source);
+ let module = lower(Node::root(&tape).unwrap()).expect("semantic IR");
+ let ControlFlow::If(chain) = at(&module, source, "@if") else {
+ panic!("expected if chain");
+ };
+ assert_eq!(
+ module
+ .control_flow
+ .iter()
+ .filter(|control| matches!(control, ControlFlow::If(_)))
+ .count(),
+ 1
+ );
+ assert_eq!(chain.branches.len(), 2);
+ assert!(chain.fallback.is_some());
+ assert_eq!(chain.origin.span.start, source.find("@if").unwrap() as u32);
+ assert_eq!(
+ chain.origin.extent.end,
+ source.rfind('}').unwrap() as u32 + 1
+ );
+ }
+
+ #[test]
+ fn computes_for_callback_mode_matrix() {
+ let source = "export function C({ xs }) @{\n\
+ \n\
+ @for (const a of xs) {
}\n\
+ @for (const b of xs; index i) {
}\n\
+ @for (const c of xs; key c.id) {
}\n\
+ @for (const d of xs; index j; key d.id) {
}\n\
+
- ,
+}
+
+#[derive(Clone, Debug)]
+enum Item {
+ Rule(Rule),
+ At(AtRule),
+ Decl(Declaration),
+}
+
+impl Item {
+ fn span(&self) -> (usize, usize) {
+ match self {
+ Self::Rule(x) => (x.start, x.end),
+ Self::At(x) => (x.start, x.end),
+ Self::Decl(x) => (x.start, x.end_with_semicolon),
+ }
+ }
+}
+
+#[derive(Clone, Debug)]
+struct Rule {
+ start: usize,
+ end: usize,
+ selectors: SelectorList,
+ block: Block,
+ parent: Option,
+ global_block: bool,
+}
+
+#[derive(Clone, Debug)]
+struct AtRule {
+ start: usize,
+ end: usize,
+ name: String,
+ prelude: String,
+ prelude_start: usize,
+ block: Option,
+}
+
+#[derive(Clone, Debug)]
+struct Declaration {
+ start: usize,
+ end_with_semicolon: usize,
+ property: String,
+ value: String,
+ value_start: usize,
+}
+
+#[derive(Clone, Debug)]
+struct Block {
+ start: usize,
+ end: usize,
+ items: Vec
- ,
+}
+
+#[derive(Clone, Debug)]
+struct SelectorList {
+ start: usize,
+ end: usize,
+ selectors: Vec,
+}
+
+#[derive(Clone, Debug)]
+struct Complex {
+ start: usize,
+ end: usize,
+ parts: Vec,
+ used: bool,
+ class_map: bool,
+}
+
+#[derive(Clone, Debug)]
+struct Relative {
+ start: usize,
+ combinator: Option<(String, usize, usize)>,
+ simple: Vec,
+ global: bool,
+ global_like: bool,
+ scoped: bool,
+}
+
+#[derive(Clone, Debug)]
+enum Simple {
+ Type(String, usize, usize),
+ Class(String, usize, usize),
+ Id(String, usize, usize),
+ Attr(AttrSelector),
+ Pseudo(Pseudo),
+ PseudoElement(usize, usize),
+ Nest(usize, usize),
+ Other(usize, usize),
+}
+
+impl Simple {
+ fn span(&self) -> (usize, usize) {
+ match self {
+ Self::Type(_, a, b)
+ | Self::Class(_, a, b)
+ | Self::Id(_, a, b)
+ | Self::PseudoElement(a, b)
+ | Self::Nest(a, b)
+ | Self::Other(a, b) => (*a, *b),
+ Self::Attr(x) => (x.start, x.end),
+ Self::Pseudo(x) => (x.start, x.end),
+ }
+ }
+}
+
+#[derive(Clone, Debug)]
+struct AttrSelector {
+ start: usize,
+ end: usize,
+ name: String,
+ op: Option,
+ value: Option,
+ insensitive: bool,
+}
+
+#[derive(Clone, Debug)]
+struct Pseudo {
+ start: usize,
+ end: usize,
+ name: String,
+ args: Option,
+}
+
+mod analysis;
+mod hash;
+mod parser;
+mod render;
+
+#[cfg(test)]
+mod tests;
+
+use analysis::*;
+use hash::sha256;
+use parser::Parser;
+use render::Render;
diff --git a/packages/compiler/src/tsrx/style/parser.rs b/packages/compiler/src/tsrx/style/parser.rs
new file mode 100644
index 000000000..22184b537
--- /dev/null
+++ b/packages/compiler/src/tsrx/style/parser.rs
@@ -0,0 +1,541 @@
+use super::*;
+
+pub(super) struct Parser<'a> {
+ src: &'a str,
+ i: usize,
+}
+
+impl<'a> Parser<'a> {
+ pub(super) fn new(src: &'a str) -> Self {
+ Self { src, i: 0 }
+ }
+
+ pub(super) fn parse(mut self) -> Result {
+ let items = self.body(None)?;
+ Ok(Sheet { items })
+ }
+
+ fn err(&self, message: impl Into) -> Result {
+ Err(StyleError {
+ message: message.into(),
+ offset: self.i,
+ })
+ }
+
+ fn body(&mut self, close: Option) -> Result, StyleError> {
+ let mut out = Vec::new();
+ loop {
+ self.trivia()?;
+ if self.i >= self.src.len() || close.is_some_and(|c| self.byte() == c) {
+ return Ok(out);
+ }
+ out.push(if self.byte() == b'@' {
+ Item::At(self.at_rule()?)
+ } else if close.is_some() {
+ self.block_item()?
+ } else {
+ Item::Rule(self.rule()?)
+ });
+ }
+ }
+
+ fn trivia(&mut self) -> Result<(), StyleError> {
+ loop {
+ while self.i < self.src.len() && self.byte().is_ascii_whitespace() {
+ self.i += 1;
+ }
+ if self.rest().starts_with("/*") {
+ let Some(n) = self.rest()[2..].find("*/") else {
+ return self.err("Unclosed CSS comment");
+ };
+ self.i += n + 4;
+ } else if self.rest().starts_with("") else {
+ return self.err("Unclosed HTML comment");
+ };
+ self.i += n + 7;
+ } else {
+ return Ok(());
+ }
+ }
+ }
+
+ fn block_item(&mut self) -> Result {
+ if self.byte() == b'@' {
+ return Ok(Item::At(self.at_rule()?));
+ }
+ let save = self.i;
+ let (_, term) = self.value_until()?;
+ self.i = save;
+ if term == b'{' {
+ Ok(Item::Rule(self.rule()?))
+ } else {
+ Ok(Item::Decl(self.declaration()?))
+ }
+ }
+
+ fn rule(&mut self) -> Result {
+ let start = self.i;
+ let selectors = self.selector_list(false)?;
+ let block = self.block()?;
+ Ok(Rule {
+ start,
+ end: block.end,
+ selectors,
+ block,
+ parent: None,
+ global_block: false,
+ })
+ }
+
+ fn at_rule(&mut self) -> Result {
+ let start = self.i;
+ self.i += 1;
+ let name = self.ident()?;
+ let prelude_start = self.i;
+ let (prelude, term) = self.value_until()?;
+ let block = if term == b'{' {
+ Some(self.block()?)
+ } else {
+ self.i += 1;
+ None
+ };
+ let end = block.as_ref().map_or(self.i, |x| x.end);
+ Ok(AtRule {
+ start,
+ end,
+ name,
+ prelude,
+ prelude_start,
+ block,
+ })
+ }
+
+ fn block(&mut self) -> Result {
+ if self.i >= self.src.len() || self.byte() != b'{' {
+ return self.err("Expected `{`");
+ }
+ let start = self.i;
+ self.i += 1;
+ let items = self.body(Some(b'}'))?;
+ if self.i >= self.src.len() {
+ return self.err("Expected `}`");
+ }
+ self.i += 1;
+ Ok(Block {
+ start,
+ end: self.i,
+ items,
+ })
+ }
+
+ fn declaration(&mut self) -> Result {
+ let start = self.i;
+ while self.i < self.src.len() && !self.byte().is_ascii_whitespace() && self.byte() != b':' {
+ self.i += 1;
+ }
+ let property = self.src[start..self.i].to_string();
+ self.ws();
+ if self.i < self.src.len() && self.byte() == b':' {
+ self.i += 1;
+ }
+ self.ws();
+ let value_start = self.i;
+ let (value, term) = self.value_until()?;
+ if value.is_empty() && !property.starts_with("--") {
+ return self.err("CSS Declaration cannot be empty");
+ }
+ if term == b';' {
+ self.i += 1;
+ }
+ Ok(Declaration {
+ start,
+ end_with_semicolon: self.i,
+ property,
+ value,
+ value_start,
+ })
+ }
+
+ fn value_until(&mut self) -> Result<(String, u8), StyleError> {
+ let start = self.i;
+ let mut quote = 0;
+ let mut escaped = false;
+ let mut parens = 0usize;
+ while self.i < self.src.len() {
+ let b = self.byte();
+ if escaped {
+ escaped = false;
+ } else if b == b'\\' {
+ escaped = true;
+ } else if quote != 0 {
+ if b == quote {
+ quote = 0;
+ }
+ } else if b == b'\'' || b == b'"' {
+ quote = b;
+ } else if b == b'(' {
+ parens += 1;
+ } else if b == b')' && parens > 0 {
+ parens -= 1;
+ } else if parens == 0 && matches!(b, b';' | b'{' | b'}') {
+ return Ok((self.src[start..self.i].trim().to_string(), b));
+ }
+ self.i += 1;
+ }
+ self.err("Unexpected end of CSS")
+ }
+
+ fn selector_list(&mut self, in_pseudo: bool) -> Result {
+ self.trivia()?;
+ let start = self.i;
+ let mut selectors = Vec::new();
+ loop {
+ selectors.push(self.complex(in_pseudo)?);
+ let end = self.i;
+ self.trivia()?;
+ let terminal = if in_pseudo { b')' } else { b'{' };
+ if self.i < self.src.len() && self.byte() == terminal {
+ return Ok(SelectorList {
+ start,
+ end,
+ selectors,
+ });
+ }
+ if self.i >= self.src.len() || self.byte() != b',' {
+ return self.err("Expected `,` in selector list");
+ }
+ self.i += 1;
+ self.trivia()?;
+ }
+ }
+
+ fn complex(&mut self, in_pseudo: bool) -> Result {
+ let start = self.i;
+ let mut parts = Vec::new();
+ let mut combinator = None;
+ loop {
+ let part_start = combinator
+ .as_ref()
+ .map_or(self.i, |x: &(String, usize, usize)| x.1);
+ let mut simple = Vec::new();
+ loop {
+ if self.i >= self.src.len() {
+ return self.err("Unexpected end of selector");
+ }
+ let b = self.byte();
+ if b == b','
+ || b == b'{'
+ || (in_pseudo && b == b')')
+ || self.rest().starts_with("||")
+ || b.is_ascii_whitespace()
+ || matches!(b, b'>' | b'+' | b'~')
+ {
+ break;
+ }
+ if in_pseudo && let Some(end) = self.nth_prefix_end() {
+ simple.push(Simple::Other(self.i, end));
+ self.i = end;
+ } else {
+ simple.push(self.simple()?);
+ }
+ }
+ let part_end = self.i;
+ if !simple.is_empty() {
+ parts.push(Relative {
+ start: part_start,
+ combinator: combinator.take(),
+ simple,
+ global: false,
+ global_like: false,
+ scoped: false,
+ });
+ }
+ let before_ws = self.i;
+ self.ws();
+ if self.i >= self.src.len()
+ || self.byte() == b','
+ || self.byte() == b'{'
+ || (in_pseudo && self.byte() == b')')
+ {
+ return Ok(Complex {
+ start,
+ end: part_end,
+ parts,
+ used: false,
+ class_map: false,
+ });
+ }
+ let (name, a, b) = if self.rest().starts_with("||") {
+ let a = self.i;
+ self.i += 2;
+ let b = self.i;
+ self.ws();
+ ("||".into(), a, b)
+ } else if matches!(self.byte(), b'>' | b'+' | b'~') {
+ let a = self.i;
+ let name = (self.byte() as char).to_string();
+ self.i += 1;
+ let b = self.i;
+ self.ws();
+ (name, a, b)
+ } else if self.i > before_ws {
+ (" ".into(), before_ws, self.i)
+ } else {
+ return self.err("Invalid selector");
+ };
+ combinator = Some((name, a, b));
+ }
+ }
+
+ fn simple(&mut self) -> Result {
+ let start = self.i;
+ match self.byte() {
+ b'&' => {
+ self.i += 1;
+ Ok(Simple::Nest(start, self.i))
+ }
+ b'.' | b'#' => {
+ let kind = self.byte();
+ self.i += 1;
+ let name = self.ident()?;
+ Ok(if kind == b'.' {
+ Simple::Class(name, start, self.i)
+ } else {
+ Simple::Id(name, start, self.i)
+ })
+ }
+ b'[' => self.attribute(),
+ b':' => self.pseudo(),
+ b'*' => {
+ self.i += 1;
+ Ok(Simple::Type("*".into(), start, self.i))
+ }
+ b if b.is_ascii_digit() => {
+ while self.i < self.src.len()
+ && (self.byte().is_ascii_digit() || self.byte() == b'.' || self.byte() == b'%')
+ {
+ self.i += 1;
+ }
+ Ok(Simple::Other(start, self.i))
+ }
+ _ => {
+ let mut name = self.ident()?;
+ if self.i < self.src.len() && self.byte() == b'|' {
+ self.i += 1;
+ name = self.ident()?;
+ }
+ Ok(Simple::Type(name, start, self.i))
+ }
+ }
+ }
+
+ /// End of the grammar's `Nth` token. It includes the whitespace after
+ /// `of`, exactly like `REGEX_NTH_OF` in `@tsrx/core`.
+ fn nth_prefix_end(&self) -> Option {
+ let rest = self.rest();
+ let lower = rest.to_ascii_lowercase();
+ for keyword in ["even", "odd"] {
+ if lower.starts_with(keyword) {
+ let end = self.i + keyword.len();
+ return nth_suffix_end(self.src, end);
+ }
+ }
+ let bytes = self.src.as_bytes();
+ let mut at = self.i;
+ if at < bytes.len() && matches!(bytes[at], b'+' | b'-') {
+ at += 1;
+ }
+ let formula_start = at;
+ let mut saw_digit_or_n = false;
+ while at < bytes.len() {
+ let byte = bytes[at];
+ if byte.is_ascii_digit() || byte.eq_ignore_ascii_case(&b'n') {
+ saw_digit_or_n = true;
+ at += 1;
+ } else if matches!(byte, b'+' | b'-') || byte.is_ascii_whitespace() {
+ at += 1;
+ } else {
+ break;
+ }
+ }
+ if at == formula_start || !saw_digit_or_n {
+ return None;
+ }
+ nth_suffix_end(self.src, at)
+ }
+
+ fn pseudo(&mut self) -> Result {
+ let start = self.i;
+ self.i += 1;
+ if self.i < self.src.len() && self.byte() == b':' {
+ self.i += 1;
+ self.ident()?;
+ if self.i < self.src.len() && self.byte() == b'(' {
+ self.skip_balanced()?;
+ }
+ return Ok(Simple::PseudoElement(start, self.i));
+ }
+ let name = self.ident()?;
+ let args = if self.i < self.src.len() && self.byte() == b'(' {
+ self.i += 1;
+ let args = self.selector_list(true)?;
+ if self.i >= self.src.len() || self.byte() != b')' {
+ return self.err("Expected `)`");
+ }
+ self.i += 1;
+ Some(args)
+ } else {
+ None
+ };
+ Ok(Simple::Pseudo(Pseudo {
+ start,
+ end: self.i,
+ name,
+ args,
+ }))
+ }
+
+ fn attribute(&mut self) -> Result {
+ let start = self.i;
+ self.i += 1;
+ self.ws();
+ let name = self.ident()?;
+ self.ws();
+ let op = ["~=", "^=", "$=", "*=", "|=", "="]
+ .into_iter()
+ .find(|op| self.rest().starts_with(op))
+ .map(str::to_string);
+ if let Some(op) = &op {
+ self.i += op.len();
+ }
+ self.ws();
+ let value = if op.is_some() {
+ let quote = if self.i < self.src.len() && matches!(self.byte(), b'\'' | b'"') {
+ let q = self.byte();
+ self.i += 1;
+ Some(q)
+ } else {
+ None
+ };
+ let a = self.i;
+ while self.i < self.src.len()
+ && quote.map_or(
+ !self.byte().is_ascii_whitespace() && self.byte() != b']',
+ |q| self.byte() != q,
+ )
+ {
+ if self.byte() == b'\\' && self.i + 1 < self.src.len() {
+ self.i += 1;
+ }
+ self.i += 1;
+ }
+ let v = self.src[a..self.i].to_string();
+ if quote.is_some() {
+ self.i += 1;
+ }
+ Some(v)
+ } else {
+ None
+ };
+ self.ws();
+ let flag_start = self.i;
+ while self.i < self.src.len() && self.byte().is_ascii_alphabetic() {
+ self.i += 1;
+ }
+ let insensitive = self.src[flag_start..self.i].contains('i');
+ self.ws();
+ if self.i >= self.src.len() || self.byte() != b']' {
+ return self.err("Expected `]`");
+ }
+ self.i += 1;
+ Ok(Simple::Attr(AttrSelector {
+ start,
+ end: self.i,
+ name,
+ op,
+ value,
+ insensitive,
+ }))
+ }
+
+ fn skip_balanced(&mut self) -> Result<(), StyleError> {
+ let mut depth = 0;
+ while self.i < self.src.len() {
+ match self.byte() {
+ b'(' => depth += 1,
+ b')' => {
+ depth -= 1;
+ if depth == 0 {
+ self.i += 1;
+ return Ok(());
+ }
+ }
+ b'\\' => self.i += 1,
+ _ => {}
+ }
+ self.i += 1;
+ }
+ self.err("Expected `)`")
+ }
+
+ fn ident(&mut self) -> Result {
+ let start = self.i;
+ if self.i < self.src.len()
+ && (self.byte().is_ascii_digit()
+ || (self.byte() == b'-'
+ && self.i + 1 < self.src.len()
+ && self.src.as_bytes()[self.i + 1].is_ascii_digit()))
+ {
+ return self.err("Unexpected CSS identifier");
+ }
+ while self.i < self.src.len() {
+ let b = self.byte();
+ if b.is_ascii_alphanumeric() || matches!(b, b'_' | b'-') || b >= 0x80 {
+ self.i += 1;
+ } else if b == b'\\' && self.i + 1 < self.src.len() {
+ self.i += 2;
+ } else {
+ break;
+ }
+ }
+ if self.i == start {
+ return self.err("Expected identifier");
+ }
+ Ok(self.src[start..self.i].to_string())
+ }
+
+ fn ws(&mut self) {
+ while self.i < self.src.len() && self.byte().is_ascii_whitespace() {
+ self.i += 1;
+ }
+ }
+ fn byte(&self) -> u8 {
+ self.src.as_bytes()[self.i]
+ }
+ fn rest(&self) -> &str {
+ &self.src[self.i..]
+ }
+}
+
+fn nth_suffix_end(source: &str, mut end: usize) -> Option {
+ let bytes = source.as_bytes();
+ let formula_end = end;
+ while end < bytes.len() && bytes[end].is_ascii_whitespace() {
+ end += 1;
+ }
+ if source[end..].starts_with("of")
+ && end + 2 < bytes.len()
+ && bytes[end + 2].is_ascii_whitespace()
+ {
+ end += 2;
+ while end < bytes.len() && bytes[end].is_ascii_whitespace() {
+ end += 1;
+ }
+ return Some(end);
+ }
+ if end < bytes.len() && matches!(bytes[end], b',' | b')') {
+ return Some(formula_end);
+ }
+ None
+}
diff --git a/packages/compiler/src/tsrx/style/render.rs b/packages/compiler/src/tsrx/style/render.rs
new file mode 100644
index 000000000..291392c32
--- /dev/null
+++ b/packages/compiler/src/tsrx/style/render.rs
@@ -0,0 +1,398 @@
+use super::*;
+
+pub(super) struct Render<'a> {
+ pub(super) source: &'a str,
+ pub(super) hash: &'a str,
+ pub(super) minify: bool,
+ pub(super) local_keyframes: &'a BTreeSet,
+}
+
+impl Render<'_> {
+ pub(super) fn items(&mut self, items: &[Item], global: bool) -> String {
+ if items.is_empty() {
+ return String::new();
+ }
+ let start = items.first().unwrap().span().0;
+ let end = items.last().unwrap().span().1;
+ let mut out = String::new();
+ let mut cursor = start;
+ for item in items {
+ let (a, b) = item.span();
+ out.push_str(&self.source[cursor..a]);
+ out.push_str(&self.item(item, global));
+ cursor = b;
+ }
+ out.push_str(&self.source[cursor..end]);
+ out
+ }
+
+ fn item(&mut self, item: &Item, global: bool) -> String {
+ match item {
+ Item::Rule(rule) => self.rule(rule, global),
+ Item::At(at) => self.at_rule(at, global),
+ Item::Decl(decl) => self.declaration(decl),
+ }
+ }
+
+ fn rule(&mut self, rule: &Rule, in_global: bool) -> String {
+ let used = rule.selectors.selectors.iter().any(|x| x.used);
+ let empty = self.rule_empty(rule);
+ if empty || (!used && !in_global) {
+ let label = if empty { "empty" } else { "unused" };
+ return format!(
+ "/* ({label}) {}*/",
+ escape_comment_close(&self.source[rule.start..rule.end])
+ );
+ }
+ if rule.global_block
+ && rule.selectors.selectors.len() == 1
+ && rule.selectors.selectors[0].parts.len() == 1
+ && rule.selectors.selectors[0].parts[0].simple.len() == 1
+ {
+ let inside = self.block_contents(&rule.block, true);
+ return if self.minify {
+ inside
+ } else {
+ format!(
+ "/* {}*/{}/*{}*/",
+ &self.source[rule.start..=rule.block.start],
+ inside,
+ &self.source[rule.block.end - 1..rule.end]
+ )
+ };
+ }
+ // `@tsrx/core` creates a fresh, unbumped specificity state for every
+ // rule selector list. Its ancestor check is keyed by
+ // `has_local_selectors`, which remains false in the analyzer; nested
+ // implicit selectors therefore receive `.hash`, not `:where(.hash)`.
+ let mut specificity = false;
+ let selectors = self.selector_list(
+ &rule.selectors,
+ in_global,
+ &mut specificity,
+ rule.parent.is_some(),
+ );
+ let body = self.block_contents(&rule.block, in_global || rule.global_block);
+ format!(
+ "{}{}{}",
+ selectors,
+ &self.source[rule.selectors.end..=rule.block.start],
+ body + &self.source[rule.block.end - 1..rule.end]
+ )
+ }
+
+ fn rule_empty(&self, rule: &Rule) -> bool {
+ if rule.global_block {
+ return rule.block.items.is_empty();
+ }
+ rule.block.items.iter().all(|item| match item {
+ Item::Decl(_) => false,
+ Item::Rule(child) => {
+ !child.selectors.selectors.iter().any(|x| x.used) || self.rule_empty(child)
+ }
+ Item::At(at) => at.block.as_ref().is_some_and(|x| x.items.is_empty()),
+ })
+ }
+
+ fn block_contents(&mut self, block: &Block, global: bool) -> String {
+ if block.items.is_empty() {
+ return self.source[block.start + 1..block.end - 1].to_string();
+ }
+ let mut out = String::new();
+ let mut cursor = block.start + 1;
+ for item in &block.items {
+ let (a, b) = item.span();
+ out.push_str(&self.source[cursor..a]);
+ out.push_str(&self.item(item, global));
+ cursor = b;
+ }
+ out.push_str(&self.source[cursor..block.end - 1]);
+ out
+ }
+
+ fn at_rule(&mut self, at: &AtRule, global: bool) -> String {
+ if strip_prefix(&at.name) == "keyframes" {
+ let raw = &self.source[at.start..at.end];
+ let name_start = at.prelude_start
+ + self.source[at.prelude_start..]
+ .find(|c: char| !c.is_whitespace())
+ .unwrap_or(0);
+ let authored = at.prelude.trim();
+ let rendered = if let Some(rendered) = authored.strip_prefix("-global-") {
+ rendered
+ } else if !global {
+ return replace_range(
+ raw,
+ name_start - at.start,
+ name_start - at.start,
+ &format!("{}-", self.hash),
+ );
+ } else {
+ authored
+ };
+ return replace_range(
+ raw,
+ name_start - at.start,
+ name_start - at.start + authored.len(),
+ rendered,
+ );
+ }
+ let Some(block) = &at.block else {
+ return self.source[at.start..at.end].to_string();
+ };
+ format!(
+ "{}{}{}",
+ &self.source[at.start..=block.start],
+ self.block_contents(block, global),
+ &self.source[block.end - 1..at.end]
+ )
+ }
+
+ fn declaration(&self, decl: &Declaration) -> String {
+ let mut raw = self.source[decl.start..decl.end_with_semicolon].to_string();
+ if matches!(
+ strip_prefix(&decl.property).as_str(),
+ "animation" | "animation-name"
+ ) {
+ let value_offset = decl.value_start - decl.start;
+ let rewritten = rewrite_animation(&decl.value, self.hash, self.local_keyframes);
+ raw = replace_range(
+ &raw,
+ value_offset,
+ value_offset + decl.value.len(),
+ &rewritten,
+ );
+ }
+ raw
+ }
+
+ fn selector_list(
+ &mut self,
+ list: &SelectorList,
+ global: bool,
+ specificity: &mut bool,
+ nested_rule: bool,
+ ) -> String {
+ let mut out = String::new();
+ let mut cursor = list.start;
+ let mut pruning = false;
+ for (index, complex) in list.selectors.iter().enumerate() {
+ let used = complex.used || global;
+ if !used && !pruning {
+ if self.minify {
+ // The run is omitted below, including one separator.
+ } else if index == 0 {
+ out.push_str(&self.source[cursor..complex.start]);
+ out.push_str("/* (unused) ");
+ } else {
+ out.push_str(" /* (unused) ");
+ }
+ cursor = complex.start;
+ pruning = true;
+ } else if used && pruning {
+ let separator = &self.source[cursor..complex.start];
+ let comma = separator.rfind(',').unwrap_or(0);
+ if !self.minify {
+ out.push_str(&self.source[cursor..cursor + comma]);
+ out.push_str("*/");
+ out.push_str(&separator[comma..]);
+ } else if index > 0 && !out.trim_end().ends_with(',') {
+ out.push(',');
+ }
+ cursor = complex.start;
+ pruning = false;
+ }
+ if used {
+ out.push_str(&self.source[cursor..complex.start]);
+ let mut complex_specificity = *specificity;
+ out.push_str(&self.complex(complex, global, &mut complex_specificity, nested_rule));
+ cursor = complex.end;
+ } else if !self.minify {
+ out.push_str(&escape_comment_close(&self.source[cursor..complex.end]));
+ cursor = complex.end;
+ } else {
+ cursor = complex.end;
+ }
+ }
+ if pruning {
+ if !self.minify {
+ out.push_str("*/");
+ }
+ } else {
+ out.push_str(&self.source[cursor..list.end]);
+ }
+ out
+ }
+
+ fn complex(
+ &mut self,
+ complex: &Complex,
+ global: bool,
+ specificity: &mut bool,
+ nested_rule: bool,
+ ) -> String {
+ let mut edits: Vec<(usize, usize, String)> = Vec::new();
+ for relative in &complex.parts {
+ for simple in &relative.simple {
+ self.simple_edits(
+ simple,
+ relative,
+ global,
+ specificity,
+ nested_rule,
+ &mut edits,
+ );
+ }
+ if relative.scoped && !global && !relative.global && !relative.global_like {
+ let modifier = if *specificity {
+ format!(":where(.{})", self.hash)
+ } else {
+ *specificity = true;
+ format!(".{}", self.hash)
+ };
+ if !(relative
+ .simple
+ .iter()
+ .any(|x| matches!(x, Simple::Nest(..)))
+ || relative.simple.len() == 1
+ && matches!(
+ &relative.simple[0],
+ Simple::Pseudo(Pseudo { name, .. }) if name == "is" || name == "where"
+ ))
+ {
+ if let Some(target) = relative
+ .simple
+ .iter()
+ .rev()
+ .find(|x| !matches!(x, Simple::Pseudo(_) | Simple::PseudoElement(..)))
+ {
+ let (a, b) = target.span();
+ if matches!(target, Simple::Type(name, ..) if name == "*") {
+ edits.push((a, b, modifier));
+ } else {
+ edits.push((b, b, modifier));
+ }
+ } else if let Some(first) = relative.simple.first() {
+ edits.push((first.span().0, first.span().0, modifier));
+ }
+ }
+ }
+ }
+ apply_edits(self.source, complex.start, complex.end, edits)
+ }
+
+ fn simple_edits(
+ &mut self,
+ simple: &Simple,
+ relative: &Relative,
+ global: bool,
+ specificity: &mut bool,
+ nested_rule: bool,
+ edits: &mut Vec<(usize, usize, String)>,
+ ) {
+ let Simple::Pseudo(pseudo) = simple else {
+ return;
+ };
+ if pseudo.name == "global" {
+ if let Some(args) = &pseudo.args {
+ edits.push((pseudo.start, args.start, String::new()));
+ edits.push((args.end, pseudo.end, String::new()));
+ } else {
+ let start = relative
+ .combinator
+ .as_ref()
+ .filter(|(name, _, _)| name == " ")
+ .map_or(pseudo.start, |(_, start, _)| *start);
+ let replacement = if nested_rule && relative.combinator.is_none() && relative.global
+ {
+ "&"
+ } else {
+ ""
+ };
+ edits.push((start, pseudo.end, replacement.into()));
+ }
+ return;
+ }
+ if matches!(pseudo.name.as_str(), "is" | "where" | "has" | "not")
+ && let Some(args) = &pseudo.args
+ {
+ let rendered = self.selector_list(args, global || relative.global, specificity, false);
+ edits.push((args.start, args.end, rendered));
+ }
+ }
+}
+
+fn rewrite_animation(value: &str, hash: &str, names: &BTreeSet) -> String {
+ let mut out = String::with_capacity(value.len());
+ let mut token = String::new();
+ for ch in value.chars().chain(std::iter::once(';')) {
+ if ch.is_whitespace() || matches!(ch, ',' | ';' | '}') {
+ if names.contains(&token) {
+ out.push_str(hash);
+ out.push('-');
+ }
+ out.push_str(&token);
+ token.clear();
+ if ch != ';' {
+ out.push(ch);
+ }
+ } else {
+ token.push(ch);
+ }
+ }
+ out
+}
+
+pub(super) fn strip_prefix(name: &str) -> String {
+ for prefix in ["-webkit-", "-moz-", "-o-", "-ms-"] {
+ if let Some(rest) = name.to_ascii_lowercase().strip_prefix(prefix) {
+ return rest.to_string();
+ }
+ }
+ name.to_ascii_lowercase()
+}
+
+pub(super) fn unescape_ident(name: &str) -> String {
+ let mut out = String::new();
+ let mut escaped = false;
+ for ch in name.chars() {
+ if escaped {
+ out.push(ch);
+ escaped = false;
+ } else if ch == '\\' {
+ escaped = true;
+ } else {
+ out.push(ch);
+ }
+ }
+ out
+}
+
+fn escape_comment_close(source: &str) -> String {
+ source.replace("*/", "*\\/")
+}
+
+fn replace_range(source: &str, start: usize, end: usize, replacement: &str) -> String {
+ format!("{}{}{}", &source[..start], replacement, &source[end..])
+}
+
+fn apply_edits(
+ source: &str,
+ start: usize,
+ end: usize,
+ mut edits: Vec<(usize, usize, String)>,
+) -> String {
+ edits.sort_by_key(|x| (x.0, x.1));
+ let mut out = String::new();
+ let mut cursor = start;
+ for (a, b, replacement) in edits {
+ if a < cursor {
+ continue;
+ }
+ out.push_str(&source[cursor..a]);
+ out.push_str(&replacement);
+ cursor = b;
+ }
+ out.push_str(&source[cursor..end]);
+ out
+}
diff --git a/packages/compiler/src/tsrx/style/tests.rs b/packages/compiler/src/tsrx/style/tests.rs
new file mode 100644
index 000000000..9ba0e8b31
--- /dev/null
+++ b/packages/compiler/src/tsrx/style/tests.rs
@@ -0,0 +1,343 @@
+use super::*;
+
+fn input<'a>(css: &'a str, elements: &'a [Element], kind: StyleKind) -> StyleInput<'a> {
+ StyleInput {
+ css,
+ location: StyleLocation {
+ filename: "App.tsrx",
+ line: 3,
+ column: 4,
+ },
+ elements,
+ kind,
+ minify: false,
+ }
+}
+
+#[test]
+fn matches_sha256_hash_and_strips_carriage_returns() {
+ let output = compile_style(input(
+ ".a .b:hover { color:red }",
+ &[],
+ StyleKind::Expression,
+ ))
+ .unwrap();
+ assert_eq!(output.hash, "tsrx-f5ea950f");
+ let cr = compile_style(StyleInput {
+ css: ".a\r {x:y}",
+ location: StyleLocation {
+ filename: "A\r.tsrx",
+ line: 1,
+ column: 0,
+ },
+ elements: &[],
+ kind: StyleKind::Expression,
+ minify: false,
+ })
+ .unwrap();
+ let plain = compile_style(StyleInput {
+ css: ".a {x:y}",
+ location: StyleLocation {
+ filename: "A.tsrx",
+ line: 1,
+ column: 0,
+ },
+ elements: &[],
+ kind: StyleKind::Expression,
+ minify: false,
+ })
+ .unwrap();
+ assert_eq!(cr.hash, plain.hash);
+}
+
+#[test]
+fn scopes_first_selector_then_uses_where() {
+ let mut parent = Element::native(1, "div").with_static_attr("class", "a");
+ parent.children.push(ElementChild::Element(
+ Element::native(2, "span").with_static_attr("class", "b"),
+ ));
+ let roots = [parent];
+ let output =
+ compile_style(input(".a .b:hover { color:red }", &roots, StyleKind::Block)).unwrap();
+ assert_eq!(
+ output.css,
+ ".a.tsrx-f5ea950f .b:where(.tsrx-f5ea950f):hover { color:red }"
+ );
+}
+
+#[test]
+fn expression_map_is_sorted_and_prunes_unreachable_rules() {
+ let css =
+ "div { color: red; }.z {a:b}.a {c:d}:global(.badge) {e:f}:global(body) { margin: 0; }";
+ let output = compile_style(input(css, &[], StyleKind::Expression)).unwrap();
+ assert_eq!(
+ output
+ .class_map
+ .iter()
+ .map(|x| x.class_name.as_str())
+ .collect::>(),
+ ["a", "badge", "z"]
+ );
+ assert!(output.css.starts_with("/* (unused) div { color: red; }*/"));
+ assert!(output.css.contains(".badge {e:f}"));
+ assert!(
+ output
+ .css
+ .contains("/* (unused) :global(body) { margin: 0; }*/")
+ );
+}
+
+#[test]
+fn rewrites_keyframes_and_animation_names() {
+ let css = "@keyframes spin {from{x:y}to{x:z}} .a {animation: 1s spin, none}";
+ let output = compile_style(input(css, &[], StyleKind::Expression)).unwrap();
+ assert_eq!(output.hash, "tsrx-6209913b");
+ assert_eq!(
+ output.css,
+ "@keyframes tsrx-6209913b-spin {from{x:y}to{x:z}} .a.tsrx-6209913b {animation: 1s tsrx-6209913b-spin, none}"
+ );
+}
+
+#[test]
+fn preserves_global_blocks_with_parity_comments() {
+ let css = ":global { body { margin: 0 } }";
+ let output = compile_style(input(css, &[], StyleKind::Block)).unwrap();
+ assert_eq!(output.hash, "tsrx-24bf0053");
+ assert_eq!(output.css, "/* :global {*/ body { margin: 0 } /*}*/");
+}
+
+#[test]
+fn prunes_against_element_tree_and_tracks_scoped_ids() {
+ let mut section = Element::native(1, "section").with_static_attr("class", "card");
+ section
+ .children
+ .push(ElementChild::Element(Element::native(2, "h2")));
+ let roots = [section];
+ let css = ".card {x:y}.card h2 {a:b}.card ol {c:d}";
+ let output = compile_style(input(css, &roots, StyleKind::Block)).unwrap();
+ assert!(output.css.contains(".card."));
+ assert!(output.css.contains("h2:where("));
+ assert!(output.css.contains("/* (unused) .card ol {c:d}*/"));
+ assert_eq!(output.scoped_elements, BTreeSet::from([1, 2]));
+
+ // Dynamic tags, attributes, and child regions are explicit
+ // conservative boundaries in the frontend model.
+ let dynamic = Element {
+ id: 3,
+ kind: ElementKind::Dynamic,
+ attributes: vec![Attribute {
+ name: "class".into(),
+ value: Some(AttributeValue::Dynamic),
+ }],
+ has_spread: false,
+ children: vec![ElementChild::Dynamic],
+ };
+ let component = Element {
+ id: 4,
+ kind: ElementKind::Component,
+ attributes: Vec::new(),
+ has_spread: false,
+ children: Vec::new(),
+ };
+ let dynamic_roots = [dynamic, component];
+ let conservative = compile_style(input(
+ ".runtime-class {x:y}",
+ &dynamic_roots,
+ StyleKind::Block,
+ ))
+ .unwrap();
+ assert!(!conservative.css.contains("(unused)"));
+ assert!(conservative.css.contains(".runtime-class.tsrx-"));
+ assert!(conservative.scoped_elements.contains(&3));
+}
+
+#[test]
+fn supports_nested_rules_and_global_keyframes() {
+ let css = ".card { color:green; span {color:red} &:hover {color:blue} } @keyframes -global-pulse {from{x:y}}";
+ let output = compile_style(input(css, &[], StyleKind::Expression)).unwrap();
+ assert_eq!(output.hash, "tsrx-25e005fa");
+ assert_eq!(
+ output.css,
+ ".card.tsrx-25e005fa { color:green; span.tsrx-25e005fa {color:red} &:hover {color:blue} } @keyframes pulse {from{x:y}}"
+ );
+}
+
+#[test]
+fn preserves_outer_trivia_and_comments_unused_selector_runs() {
+ let roots = [
+ Element::native(1, "div").with_static_attr("class", "a"),
+ Element::native(2, "div").with_static_attr("class", "c"),
+ ];
+ let css = " .a, .b, .c {x:y}\n ";
+ let output = compile_style(input(css, &roots, StyleKind::Block)).unwrap();
+ assert_eq!(
+ output.css,
+ " .a.tsrx-99f3dd6b /* (unused) .b*/, .c.tsrx-99f3dd6b {x:y}\n "
+ );
+}
+
+#[test]
+fn parses_and_conservatively_keeps_column_combinators() {
+ let roots = [Element::native(1, "div").with_static_attr("class", "b")];
+ let css = ".a || .b {x:y}";
+ let output = compile_style(input(css, &roots, StyleKind::Block)).unwrap();
+ assert_eq!(output.hash, "tsrx-f8aa311b");
+ assert_eq!(output.css, ".a || .b.tsrx-f8aa311b {x:y}");
+}
+
+#[test]
+fn preserves_nth_of_selector_lists_while_pruning_conservatively() {
+ let roots = [Element::native(1, "li")];
+ let css = "li:nth-child(2n + 1 of .featured, :global(.external)) {x:y}";
+ let output = compile_style(input(css, &roots, StyleKind::Block)).unwrap();
+ assert_eq!(output.hash, "tsrx-10770a85");
+ assert_eq!(
+ output.css,
+ "li.tsrx-10770a85:nth-child(2n + 1 of .featured, :global(.external)) {x:y}"
+ );
+}
+
+#[test]
+fn preserves_nth_last_child_formulas() {
+ let roots = [Element::native(1, "li")];
+ let css = "li:nth-last-child(odd) {x:y}";
+ let output = compile_style(input(css, &roots, StyleKind::Block)).unwrap();
+ assert_eq!(output.hash, "tsrx-0d1d03e4");
+ assert_eq!(output.css, "li.tsrx-0d1d03e4:nth-last-child(odd) {x:y}");
+}
+
+#[test]
+fn removes_global_modifier_whitespace_and_adds_nested_ampersand() {
+ let roots = [Element::native(1, "div")];
+ let outer = compile_style(input("div :global.x {a:b}", &roots, StyleKind::Block)).unwrap();
+ assert_eq!(outer.css, "div.tsrx-a070b2d0.x {a:b}");
+
+ let nested = compile_style(input("div { :global.x {a:b} }", &roots, StyleKind::Block)).unwrap();
+ assert_eq!(nested.css, "div.tsrx-eec6818f { &.x {a:b} }");
+}
+
+#[test]
+fn components_do_not_match_native_type_selectors() {
+ let roots = [Element {
+ id: 1,
+ kind: ElementKind::Component,
+ attributes: Vec::new(),
+ has_spread: false,
+ children: Vec::new(),
+ }];
+ let output = compile_style(input("div {x:y}", &roots, StyleKind::Block)).unwrap();
+ assert_eq!(output.hash, "tsrx-3853b06d");
+ assert_eq!(output.css, "/* (unused) div {x:y}*/");
+}
+
+#[test]
+fn matches_the_complete_dynamic_attribute_whitelist() {
+ let whitelist: &[(&str, &[&str])] = &[
+ ("details", &["open"]),
+ ("dialog", &["open"]),
+ ("form", &["novalidate"]),
+ (
+ "iframe",
+ &[
+ "allow",
+ "allowfullscreen",
+ "allowpaymentrequest",
+ "loading",
+ "referrerpolicy",
+ ],
+ ),
+ ("img", &["loading"]),
+ (
+ "input",
+ &[
+ "accept",
+ "autocomplete",
+ "capture",
+ "checked",
+ "disabled",
+ "max",
+ "maxlength",
+ "min",
+ "minlength",
+ "multiple",
+ "pattern",
+ "placeholder",
+ "readonly",
+ "required",
+ "size",
+ "step",
+ ],
+ ),
+ ("object", &["typemustmatch"]),
+ ("ol", &["reversed", "start", "type"]),
+ ("optgroup", &["disabled"]),
+ ("option", &["disabled", "selected"]),
+ ("script", &["async", "defer", "nomodule", "type"]),
+ ("select", &["disabled", "multiple", "required", "size"]),
+ (
+ "textarea",
+ &[
+ "autocomplete",
+ "disabled",
+ "maxlength",
+ "minlength",
+ "placeholder",
+ "readonly",
+ "required",
+ "rows",
+ "wrap",
+ ],
+ ),
+ (
+ "video",
+ &["autoplay", "controls", "loop", "muted", "playsinline"],
+ ),
+ ];
+ for &(tag, attributes) in whitelist {
+ let roots = [Element::native(1, tag)];
+ for &attribute in attributes {
+ let css = format!("{tag}[{attribute}]{{x:y}}");
+ let output = compile_style(input(&css, &roots, StyleKind::Block)).unwrap();
+ assert!(
+ !output.css.contains("(unused)"),
+ "{tag}[{attribute}] was pruned"
+ );
+ }
+ }
+
+ let roots = [
+ Element::native(1, "input"),
+ Element::native(2, "iframe"),
+ Element::native(3, "form"),
+ ];
+ let css =
+ "input[placeholder] {x:y} iframe[loading] {a:b} form[novalidate]{c:d} input[notreal]{d:e}";
+ let output = compile_style(input(css, &roots, StyleKind::Block)).unwrap();
+ assert_eq!(output.hash, "tsrx-f5567425");
+ assert_eq!(
+ output.css,
+ "input[placeholder].tsrx-f5567425 {x:y} iframe[loading].tsrx-f5567425 {a:b} form[novalidate].tsrx-f5567425{c:d} /* (unused) input[notreal]{d:e}*/"
+ );
+}
+
+#[test]
+fn optionally_preserves_class_map_selectors_for_style_refs() {
+ let output = compile_style_with_class_map_selectors(
+ input(".kept {x:y} div {a:b}", &[], StyleKind::Block),
+ true,
+ )
+ .unwrap();
+ assert_eq!(output.hash, "tsrx-6c055f88");
+ assert_eq!(
+ output.css,
+ ".kept.tsrx-6c055f88 {x:y} /* (unused) div {a:b}*/"
+ );
+ assert_eq!(output.class_map[0].class_name, "kept");
+}
+
+#[test]
+fn rejects_global_in_the_middle() {
+ let error =
+ compile_style(input(".a :global(.x) .b {x:y}", &[], StyleKind::Expression)).unwrap_err();
+ assert!(error.message.contains("not in the middle"));
+}
diff --git a/packages/compiler/src/tsrx/style_projection.rs b/packages/compiler/src/tsrx/style_projection.rs
new file mode 100644
index 000000000..8553db47e
--- /dev/null
+++ b/packages/compiler/src/tsrx/style_projection.rs
@@ -0,0 +1,737 @@
+//! Frontend planning for TSRX scoped styles.
+//!
+//! This module translates parser tape into the CSS engine's element model,
+//! assigns style actions to authored nodes, and prepares renderer-facing hash
+//! and ref metadata. It intentionally owns no general TSRX construct emission.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use super::project::ProjectError;
+use super::{
+ semantic::SolidTsrxModule,
+ style::{
+ self, Attribute, AttributeValue, ClassMapEntry, Element, ElementChild, ElementKind,
+ StyleInput, StyleKind, StyleLocation,
+ },
+ tape::{self, Node},
+};
+
+#[derive(Clone)]
+pub(super) enum StyleAction {
+ Remove,
+ ClassMap(Vec),
+ EmptyElement,
+}
+
+#[derive(Clone)]
+pub(super) struct RefSetup<'t> {
+ pub(super) target: Node<'t>,
+ pub(super) class_map: Vec,
+ pub(super) temp_name: Option,
+}
+
+pub(super) struct StyleProjection<'t> {
+ pub(super) actions: BTreeMap,
+ pub(super) element_hashes: BTreeMap>,
+ pub(super) owner_setups: BTreeMap>>,
+ pub(super) css: String,
+ pub(super) css_hash: Option,
+}
+
+pub(super) fn plan<'s, 't>(
+ source: &'s str,
+ filename: &'s str,
+ module: &SolidTsrxModule<'t>,
+) -> Result, ProjectError> {
+ StyleProcessor::process(source, filename, module.root)
+}
+
+struct StyleProcessor<'s, 't> {
+ source: &'s str,
+ filename: &'s str,
+ consumed: BTreeSet,
+ actions: BTreeMap,
+ element_hashes: BTreeMap>,
+ owner_setups: BTreeMap>>,
+ stylesheets: Vec<(String, String)>,
+ identifiers: BTreeSet,
+ next_temp: usize,
+}
+
+impl<'s, 't> StyleProcessor<'s, 't> {
+ fn process(
+ source: &'s str,
+ filename: &'s str,
+ root: Node<'t>,
+ ) -> Result, ProjectError> {
+ let mut identifiers = BTreeSet::new();
+ tape::walk(root, &mut |node| {
+ if node.ty() == "Identifier"
+ && let Some(name) = node.str_field("name")
+ {
+ identifiers.insert(name.to_string());
+ }
+ true
+ });
+ let mut processor = Self {
+ source,
+ filename,
+ consumed: BTreeSet::new(),
+ actions: BTreeMap::new(),
+ element_hashes: BTreeMap::new(),
+ owner_setups: BTreeMap::new(),
+ stylesheets: Vec::new(),
+ identifiers,
+ next_temp: 0,
+ };
+ processor.visit(root, None)?;
+ let css = processor
+ .stylesheets
+ .iter()
+ .map(|(css, _)| css.as_str())
+ .collect();
+ let hashes: Vec<_> = processor
+ .stylesheets
+ .iter()
+ .map(|(_, hash)| hash.as_str())
+ .collect();
+ Ok(StyleProjection {
+ actions: processor.actions,
+ element_hashes: processor.element_hashes,
+ owner_setups: processor.owner_setups,
+ css,
+ css_hash: (!hashes.is_empty()).then(|| hashes.join(" ")),
+ })
+ }
+
+ fn visit(&mut self, node: Node<'t>, parent: Option>) -> Result<(), ProjectError> {
+ if node.ty() == "JSXStyleElement" {
+ let start = span_of(node)?.0;
+ if !self.consumed.contains(&start) {
+ if is_style_expression_position(parent) {
+ self.compile_expression_style(node)?;
+ } else {
+ self.actions.insert(start, StyleAction::EmptyElement);
+ }
+ }
+ return Ok(());
+ }
+
+ if node.ty() == "JSXCodeBlock"
+ && let Some(render) = node.node_field("render")
+ && is_native_render_root(render)
+ {
+ self.prepare_runtime_scope(node, render)?;
+ } else if matches!(node.ty(), "JSXElement" | "JSXFragment") {
+ self.prepare_runtime_scope(node, node)?;
+ }
+
+ if node.ty() == "JSXForExpression" {
+ self.mark_unowned_styles(node);
+ return Ok(());
+ }
+ let skipped_pending = (node.ty() == "JSXTryExpression")
+ .then(|| node.node_field("pending"))
+ .flatten();
+ for child in semantic_children(node) {
+ if skipped_pending.is_some_and(|pending| pending.span() == child.span()) {
+ self.mark_unowned_styles(child);
+ } else {
+ self.visit(child, Some(node))?;
+ }
+ }
+ Ok(())
+ }
+
+ fn mark_unowned_styles(&mut self, node: Node<'t>) {
+ if is_function_or_class_boundary(node) {
+ return;
+ }
+ if node.ty() == "JSXStyleElement" {
+ if let Some((start, _)) = node.span()
+ && !self.consumed.contains(&start)
+ {
+ self.actions.insert(start, StyleAction::EmptyElement);
+ }
+ return;
+ }
+ for child in structural_children(node, StructuralMode::Runtime) {
+ self.mark_unowned_styles(child);
+ }
+ }
+
+ fn consume_runtime_styles(&mut self, node: Node<'t>) {
+ if is_function_or_class_boundary(node) {
+ return;
+ }
+ if node.ty() == "JSXStyleElement" {
+ if let Some((start, _)) = node.span() {
+ self.consumed.insert(start);
+ self.actions.insert(start, StyleAction::Remove);
+ }
+ return;
+ }
+ for child in structural_children(node, StructuralMode::Runtime) {
+ self.consume_runtime_styles(child);
+ }
+ }
+
+ fn prepare_runtime_scope(
+ &mut self,
+ setup_owner: Node<'t>,
+ render_owner: Node<'t>,
+ ) -> Result<(), ProjectError> {
+ let render_children = structural_children(render_owner, StructuralMode::Runtime);
+ let mut styles = Vec::new();
+ for child in &render_children {
+ collect_runtime_styles(*child, &self.consumed, &mut styles);
+ }
+ if styles.len() > 1 {
+ return Err(error(
+ "TSRX fragments can only have one style tag",
+ styles[1],
+ ));
+ }
+ let Some(style_node) = styles.first().copied() else {
+ return Ok(());
+ };
+ let style_start = span_of(style_node)?.0;
+ if self.consumed.contains(&style_start) {
+ return Ok(());
+ }
+
+ let (css, location) = self.style_source(style_node)?;
+ let roots = build_style_elements(&render_children);
+ let mut annotatable = BTreeSet::new();
+ collect_annotatable_ids(&roots, &mut annotatable);
+ let refs = style_ref_targets(style_node);
+ let output = style::compile_style_with_class_map_selectors(
+ StyleInput {
+ css,
+ location,
+ elements: &roots,
+ kind: StyleKind::Block,
+ minify: false,
+ },
+ !refs.is_empty(),
+ )
+ .map_err(|style_error| self.style_error(style_node, style_error))?;
+ if !refs.is_empty() {
+ let owner_start = span_of(setup_owner)?.0;
+ for target in refs {
+ self.add_ref_setup(owner_start, target, output.class_map.clone());
+ }
+ }
+ for id in annotatable {
+ self.element_hashes
+ .entry(id)
+ .or_default()
+ .push(output.hash.clone());
+ }
+ self.consume_runtime_styles(render_owner);
+ self.stylesheets.push((output.css, output.hash));
+ Ok(())
+ }
+
+ fn compile_expression_style(&mut self, style_node: Node<'t>) -> Result<(), ProjectError> {
+ let start = span_of(style_node)?.0;
+ let (css, location) = self.style_source(style_node)?;
+ let output = style::compile_style(StyleInput {
+ css,
+ location,
+ elements: &[],
+ kind: StyleKind::Expression,
+ minify: false,
+ })
+ .map_err(|style_error| self.style_error(style_node, style_error))?;
+ self.actions
+ .insert(start, StyleAction::ClassMap(output.class_map));
+ self.stylesheets.push((output.css, output.hash));
+ Ok(())
+ }
+
+ fn style_source(&self, node: Node<'t>) -> Result<(&'s str, StyleLocation<'s>), ProjectError> {
+ let css = node.str_field("css").ok_or_else(|| {
+ error(
+ "A TSRX \n \n \n}\n";
+ let filename = "/exact/components/card.tsrx";
+ let outputs: Vec<_> = [Generate::Dom, Generate::Ssr, Generate::Universal]
+ .into_iter()
+ .map(|generate| {
+ compile(
+ source,
+ &CompileOptions {
+ filename: Some(filename.into()),
+ ..fixture_options(generate)
+ },
+ )
+ .expect("scoped styles compile")
+ })
+ .collect();
+ let expected_css = outputs[0].css.as_deref().expect("TSRX CSS result");
+ let expected_hash = outputs[0].css_hash.as_deref().expect("scope hash");
+ assert!(expected_css.contains(&format!(".used.{expected_hash}")));
+ assert!(expected_css.contains("(unused)"), "{expected_css}");
+ for output in &outputs {
+ assert_eq!(output.css.as_deref(), Some(expected_css));
+ assert_eq!(output.css_hash.as_deref(), Some(expected_hash));
+ assert!(!output.code.contains(" <>\n \n \n \n;",
+ );
+ assert!(
+ message.contains("TSRX fragments can only have one style tag (3:2)"),
+ "style diagnostic: {message}"
+ );
+}
+
+#[test]
+fn rejects_return_inside_an_if_branch() {
+ let message = compile_error(
+ "export function C({ ok }) @{\n
\n @if (ok) {\n return
no
;\n }\n
@for (const x of xs) { return - {x}
; }
}",
+ "Return statements are not allowed",
+ ),
+ (
+ "continue escaping @for",
+ "export function C({ xs }) @{ @for (const x of xs) { continue; - {x}
}
}",
+ "Continue statements are not allowed",
+ ),
+ (
+ "break escaping @switch",
+ "export const C = ({ x }) => @switch (x) { @case 1: { break; } };",
+ "Break statements are not allowed",
+ ),
+ (
+ "for-await",
+ "export function C({ xs }) @{ @for await (const x of xs) { - {x}
}
}",
+ "`for await` is not supported",
+ ),
+ (
+ "for-in",
+ "export function C({ obj }) @{ @for (const key in obj) { - {key}
}
}",
+ "@for must iterate with for...of",
+ ),
+ (
+ "statement after output",
+ "export function C() @{ ; const x = 1; }",
+ "render expression precedes another statement",
+ ),
+ (
+ "multiple output nodes",
+ "export function C() @{ ; }",
+ "render expression precedes another statement",
+ ),
+ (
+ "@finally",
+ "export const C = () => @try { } @finally { };",
+ "expected an `@pending` or `@catch` clause",
+ ),
+ (
+ "spaced statement-container sigil",
+ "export function C() @ { }",
+ "Expected a semicolon",
+ ),
+ (
+ "spaced lazy-pattern sigil",
+ "export function C({ x }) @{ const & { value } = x; {value}
}",
+ "Unexpected token",
+ ),
+ ];
+
+ for (name, source, expected) in cases {
+ let message = compile_error(source);
+ assert!(
+ message.contains(expected),
+ "{name} diagnostic must contain {expected:?}: {message}"
+ );
+ }
+}
+
+#[test]
+fn unicode_offsets_preserve_authored_diagnostic_coordinates() {
+ let message = compile_error(
+ "const emoji = \"🚀\";\nexport function C() @{\n \n @if (true) { return
; }\n
{plain.name}
}
+ @for (const indexed of rows; index index) { {indexed.name}:{index}
}
+ @for (const keyed of rows; key keyed.id) { {keyed.name}
}
+ @for (const both of rows; index position; key both.id) { {both.name}:{position}
}
+ @for (const { name = "missing", ...rest } of rows; index offset) {
+ {name}:{rest.extra}:{offset}
+ }
+ @try { } @catch (error) { {error.message}
}
+
+}"#;
+ let output = project(source);
+
+ assert!(output.code.contains("from \"solid-js\""));
+ assert!(output.code.contains("<__tsrx_For0"));
+ assert!(output.code.contains("<__tsrx_Errored0"));
+ assert!(output.code.contains("plain.name"));
+ assert!(!output.code.contains("plain().name"));
+ assert!(output.code.contains("indexed().name"));
+ assert!(output.code.contains("keyed().name"));
+ assert!(output.code.contains("both().name"));
+ assert!(output.code.contains("position()"));
+ assert!(output.code.contains("keyed={false}"));
+ assert!(output.code.contains("__lazy"));
+ assert!(output.code.contains(".name"));
+ assert!(output.code.contains(".extra"));
+ assert!(output.code.contains("error().message"));
+
+ let runtime = compile(
+ source,
+ &CompileOptions {
+ filename: Some("typecheck.tsrx".into()),
+ syntax: Syntax::Tsrx,
+ ..CompileOptions::default()
+ },
+ )
+ .expect("runtime projection");
+ for shared_semantic_read in ["indexed().name", "error().message"] {
+ assert!(
+ runtime.code.contains(shared_semantic_read),
+ "runtime and tooling must share {shared_semantic_read}: {}",
+ runtime.code
+ );
+ }
+}
+
+#[test]
+fn typecheck_helper_aliases_do_not_capture_authored_bindings_or_elements() {
+ let source = r#"const __tsrx_For0 = "taken";
+const For = (props: { children?: unknown }) => props.children;
+export function Rows({ rows }: { rows: { name: string }[] }) @{
+ <>
+ authored
+ @for (const row of rows; index index) { {row.name}:{index}
}
+
+}"#;
+ let output = project(source);
+
+ assert!(
+ output.code.contains("For as __tsrx_For1"),
+ "{}",
+ output.code
+ );
+ assert!(
+ output.code.contains("authored"),
+ "{}",
+ output.code
+ );
+ assert!(output.code.contains("<__tsrx_For1"), "{}", output.code);
+}
+
+#[test]
+fn projects_lazy_defaults_dynamic_tags_and_scoped_styles() {
+ let source = r#"export function Card({ model, Tag }: Props) @{
+ const &{ title = "untitled", nested: { count = 0 } } = model;
+ <>
+
+ {title}:{count}
+ <{Tag} class="card" />
+
+}"#;
+ let output = project(source);
+
+ assert!(output.code.contains("const __lazy0 = model"));
+ assert!(output.code.contains("=== void 0"));
+ assert!(
+ output.code.contains("<__tsrx_Dynamic0 component={Tag}"),
+ "{}",
+ output.code
+ );
+ assert!(output.code.contains("from \"@solidjs/web\""));
+ assert!(!output.code.contains("
+ "}
+
+}"#;
+ let output = project(source);
+ assert!(output.code.contains(" }"#,
+ r#"export function Assets() @{ <> }"#,
+ r#"export function Assets() @{ <> }"#,
+ ] {
+ let runtime = compile(
+ source,
+ &CompileOptions {
+ filename: Some("assets.tsrx".into()),
+ syntax: Syntax::Tsrx,
+ ..CompileOptions::default()
+ },
+ )
+ .expect("runtime projection accepts authored embed order");
+ assert!(runtime.code.contains("script"));
+
+ let tooling = project(source);
+ assert_eq!(
+ tooling
+ .embedded_regions
+ .iter()
+ .filter(|region| region.kind == TsrxEmbeddedRegionKind::Css)
+ .count(),
+ 1
+ );
+ assert_eq!(
+ tooling
+ .embedded_regions
+ .iter()
+ .filter(|region| region.kind == TsrxEmbeddedRegionKind::Script)
+ .count(),
+ source.matches("