refactor(compiler-rs): use workspace

Author: zhiyuanzmj

packages/compiler-rs/Cargo.toml

@@ -1,4 +1,3 @@
-
 [package]
 authors = ["zhiyuanzmj <260480378@qq.com>"]
 edition = "2024"
@@ -12,9 +11,14 @@ crate-type = ["cdylib", "rlib"]
 default = ["napi"]
 napi = []
 
-[dependencies]
+[workspace]
+resolver = "3"
+members = ["crates/*"]
+
+[workspace.dependencies]
 napi = { version = "3.3.0", features = ["napi9"] }
 napi-derive = "3.3.0"
+
 oxc_parser = "0.99.0"
 oxc_ast = "0.99.0"
 oxc_allocator = "0.99.0"
@@ -26,6 +30,25 @@ oxc_codegen = "0.99.0"
 phf = "0.13.1"
 indexmap = "2.12.0"
 
+vdom = { path = "crates/vdom" }
+vapor = { path = "crates/vapor" }
+common = { path = "crates/common" }
+
+[dependencies]
+napi = { workspace = true }
+napi-derive = { workspace = true }
+
+oxc_parser = { workspace = true }
+oxc_ast = { workspace = true }
+oxc_allocator = { workspace = true }
+oxc_span = { workspace = true }
+oxc_traverse = { workspace = true }
+oxc_semantic = { workspace = true }
+oxc_codegen = { workspace = true }
+
+common = { workspace = true }
+vapor = { workspace = true }
+
 [dev-dependencies]
 insta = "1.43.2"
 criterion = "0.7.0"

packages/compiler-rs/benches/bench.rs

@@ -1,4 +1,4 @@
-use compiler_rs::transform::transform;
+use compiler_rs::transform;
 use criterion::{Criterion, criterion_group, criterion_main};
 
 fn bench_compile(b: &mut Criterion) {

packages/compiler-rs/compiler-rs.wasi-browser.js

@@ -56,6 +56,5 @@ const {
   },
 })
 export default __napiModule.exports
-export const compile = __napiModule.exports.compile
 export const ErrorCodes = __napiModule.exports.ErrorCodes
 export const transform = __napiModule.exports.transform

packages/compiler-rs/compiler-rs.wasi.cjs

@@ -108,6 +108,5 @@ const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule
   },
 })
 module.exports = __napiModule.exports
-module.exports.compile = __napiModule.exports.compile
 module.exports.ErrorCodes = __napiModule.exports.ErrorCodes
 module.exports.transform = __napiModule.exports.transform

packages/compiler-rs/crates/common/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "common"
+version = "0.1.0"
+edition = "2024"
+
+[features]
+default = ["napi"]
+napi = []
+
+[dependencies]
+oxc_span = { workspace = true }
+oxc_ast = { workspace = true }
+oxc_traverse = { workspace = true }
+oxc_allocator = { workspace = true }
+oxc_semantic = { workspace = true }
+
+napi-derive = { workspace = true }
+napi = { workspace = true }
+phf = { workspace = true }

packages/compiler-rs/src/utils/check.rs renamed to packages/compiler-rs/crates/common/src/check.rs

@@ -6,7 +6,7 @@ use oxc_span::GetSpan;
 use oxc_traverse::{Ancestor, TraverseAncestry};
 use phf::phf_set;
 
-use crate::{ir::index::SimpleExpressionNode, utils::expression::is_globally_allowed};
+use crate::expression::{SimpleExpressionNode, is_globally_allowed};
 
 pub fn is_member_expression(exp: &SimpleExpressionNode) -> bool {
   let Some(ast) = &exp.ast else { return false };
@@ -638,3 +638,58 @@ fn is_in_desctructure_assignment(parent: &Ancestor, ancestry: &TraverseAncestry)
   }
   false
 }
+
+// events
+static DELEGATED_EVENTS: phf::Set<&'static str> = phf_set! {
+    "beforeinput",
+    "click",
+    "dblclick",
+    "contextmenu",
+    "focusin",
+    "focusout",
+    "input",
+    "keydown",
+    "keyup",
+    "mousedown",
+    "mousemove",
+    "mouseout",
+    "mouseover",
+    "mouseup",
+    "pointerdown",
+    "pointermove",
+    "pointerout",
+    "pointerover",
+    "pointerup",
+    "touchend",
+    "touchmove",
+    "touchstart"
+};
+
+pub fn is_delegated_events(s: &str) -> bool {
+  DELEGATED_EVENTS.contains(s)
+}
+
+pub fn is_event_option_modifier(modifier: &str) -> bool {
+  matches!(modifier, "passive" | "once" | "capture")
+}
+
+pub fn is_non_key_modifier(modifier: &str) -> bool {
+  matches!(
+    modifier,
+    // event propagation management
+    "stop" | "prevent" | "self" |
+    // system modifiers + exact
+    "ctrl" | "shift" | "alt" | "meta" | "exact" |
+    // mouse
+    "middle"
+  )
+}
+
+// left & right could be mouse or key modifiers based on event type
+pub fn maybe_key_modifier(modifier: &str) -> bool {
+  matches!(modifier, "left" | "right")
+}
+
+pub fn is_keyboard_event(key: &str) -> bool {
+  matches!(key, "onkeyup" | "onkeydown" | "onkeypress")
+}

packages/compiler-rs/src/utils/directive.rs renamed to packages/compiler-rs/crates/common/src/directive.rs

@@ -1,16 +1,20 @@
 use napi::bindgen_prelude::{Either, Either3};
 use oxc_ast::ast::{JSXAttribute, JSXAttributeItem, JSXAttributeName, JSXElement};
-use oxc_span::SPAN;
+use oxc_span::{SPAN, Span};
 
-use crate::{
-  ir::index::{DirectiveNode, SimpleExpressionNode},
-  transform::TransformContext,
-};
+use crate::expression::SimpleExpressionNode;
 
-pub fn resolve_directive<'a>(
-  node: &'a mut JSXAttribute<'a>,
-  context: &TransformContext<'a>,
-) -> DirectiveNode<'a> {
+#[derive(Debug)]
+pub struct DirectiveNode<'a> {
+  // the normalized name without prefix or shorthands, e.g. "bind", "on"
+  pub name: String,
+  pub exp: Option<SimpleExpressionNode<'a>>,
+  pub arg: Option<SimpleExpressionNode<'a>>,
+  pub modifiers: Vec<SimpleExpressionNode<'a>>,
+  pub loc: Span,
+}
+
+pub fn resolve_directive<'a>(node: &'a mut JSXAttribute<'a>, source: &'a str) -> DirectiveNode<'a> {
   let mut arg_string = String::new();
   let mut name_string = match &node.name {
     JSXAttributeName::Identifier(name) => name.name.to_string(),
@@ -84,7 +88,7 @@ pub fn resolve_directive<'a>(
   let exp = node
     .value
     .as_mut()
-    .map(|exp| SimpleExpressionNode::new(Either3::C(exp), context));
+    .map(|exp| SimpleExpressionNode::new(Either3::C(exp), source));
 
   let modifiers = modifiers
     .into_iter()

packages/compiler-rs/src/utils/dom.rs renamed to packages/compiler-rs/crates/common/src/dom.rs

@@ -4,10 +4,7 @@ use oxc_ast::ast::{Expression, JSXAttributeValue, JSXChild};
 use oxc_span::{GetSpan, SPAN, Span};
 use phf::phf_set;
 
-use crate::{
-  transform::TransformContext,
-  utils::text::{get_text_like_value, resolve_jsx_text},
-};
+use crate::text::{get_text_like_value, resolve_jsx_text};
 
 #[derive(Debug)]
 pub struct SimpleExpressionNode<'a> {
@@ -42,7 +39,7 @@ impl<'a> Default for SimpleExpressionNode<'a> {
 impl<'a> SimpleExpressionNode<'a> {
   pub fn new(
     node: Either3<&'a mut Expression<'a>, &'a mut JSXChild<'a>, &'a mut JSXAttributeValue<'a>>,
-    context: &TransformContext<'a>,
+    source: &'a str,
   ) -> SimpleExpressionNode<'a> {
     let mut is_static = false;
     let mut ast = None;
@@ -51,27 +48,27 @@ impl<'a> SimpleExpressionNode<'a> {
       Either3::A(node) => {
         loc = node.span();
         ast = Some(node);
-        loc.source_text(context.ir.borrow().source).to_string()
+        loc.source_text(source).to_string()
       }
       Either3::B(node) => match node {
         JSXChild::ExpressionContainer(node) => {
           let expression = node.expression.to_expression_mut();
           loc = expression.span();
           ast = Some(expression);
-          loc.source_text(context.ir.borrow().source).to_string()
+          loc.source_text(source).to_string()
         }
         JSXChild::Text(node) => {
           is_static = true;
           resolve_jsx_text(node)
         }
         JSXChild::Element(node) => {
-          context.ir.borrow().source[node.span.start as usize..node.span.end as usize].to_string()
+          source[node.span.start as usize..node.span.end as usize].to_string()
         }
         JSXChild::Fragment(node) => {
-          context.ir.borrow().source[node.span.start as usize..node.span.end as usize].to_string()
+          source[node.span.start as usize..node.span.end as usize].to_string()
         }
         JSXChild::Spread(node) => {
-          context.ir.borrow().source[node.span.start as usize..node.span.end as usize].to_string()
+          source[node.span.start as usize..node.span.end as usize].to_string()
         }
       },
       Either3::C(node) => match node {
@@ -80,18 +77,18 @@ impl<'a> SimpleExpressionNode<'a> {
           is_static = matches!(expression, Expression::StringLiteral(_));
           loc = expression.span();
           ast = Some(expression);
-          loc.source_text(context.ir.borrow().source).to_string()
+          loc.source_text(source).to_string()
         }
         JSXAttributeValue::StringLiteral(node) => {
           is_static = true;
           loc = node.span;
           node.value.to_string()
         }
         JSXAttributeValue::Element(node) => {
-          context.ir.borrow().source[node.span.start as usize..node.span.end as usize].to_string()
+          source[node.span.start as usize..node.span.end as usize].to_string()
         }
         JSXAttributeValue::Fragment(node) => {
-          context.ir.borrow().source[node.span.start as usize..node.span.end as usize].to_string()
+          source[node.span.start as usize..node.span.end as usize].to_string()
         }
       },
     };