fusee-framework 2.7.0 → 2.7.1

package/framework/core/rust-compiler/src/lexer.rs

@@ -1,414 +0,0 @@
-use crate::args;
-use crate::ast::{Loc, Pos};
-use crate::errors::{CompileError, ErrorCode};
-use serde::Serialize;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
-pub enum TokenType {
-    TagOpen,
-    TagOpenClose,
-    TagClose,
-    TagSelfClose,
-    Comment,
-    AttrName,
-    AttrEquals,
-    AttrValue,
-    Text,
-    MustacheOpen,
-    MustacheExpr,
-    MustacheClose,
-    Eof,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct Token {
-    pub ttype: TokenType,
-    pub value: String,
-    pub loc: Loc,
-}
-
-#[derive(PartialEq, Eq, Clone, Copy)]
-enum Mode {
-    Text,
-    Tag,
-}
-
-pub fn tokenize(source: &str) -> Result<Vec<Token>, CompileError> {
-    let mut lexer = Lexer::new(source);
-    lexer.tokenize()
-}
-
-struct Lexer {
-    chars: Vec<char>,
-    source: String,
-    tokens: Vec<Token>,
-    pos: usize,
-    line: usize,
-    col: usize,
-    mode: Mode,
-}
-
-impl Lexer {
-    fn new(source: &str) -> Self {
-        Lexer {
-            chars: source.chars().collect(),
-            source: source.to_string(),
-            tokens: Vec::new(),
-            pos: 0,
-            line: 1,
-            col: 1,
-            mode: Mode::Text,
-        }
-    }
-
-    fn tokenize(&mut self) -> Result<Vec<Token>, CompileError> {
-        while !self.eof() {
-            match self.mode {
-                Mode::Text => self.read_text()?,
-                Mode::Tag => self.read_in_tag()?,
-            }
-        }
-        let start = self.start_pos();
-        self.push(TokenType::Eof, String::new(), start);
-        Ok(std::mem::take(&mut self.tokens))
-    }
-
-    fn read_text(&mut self) -> Result<(), CompileError> {
-        if self.looking_at("<!--") {
-            return self.read_comment();
-        }
-        if self.looking_at("</") {
-            return self.read_closing_tag();
-        }
-        if self.peek() == Some('<') && self.is_tag_name_start(self.peek_at(1)) {
-            return self.read_open_tag();
-        }
-        if self.looking_at("{{") {
-            return self.read_mustache();
-        }
-
-        let start = self.start_pos();
-        let mut text = String::new();
-        while !self.eof() {
-            if self.peek() == Some('<') || self.looking_at("{{") {
-                break;
-            }
-            text.push(self.advance());
-        }
-        if !text.is_empty() {
-            self.push(TokenType::Text, text, start);
-        }
-        Ok(())
-    }
-
-    fn read_open_tag(&mut self) -> Result<(), CompileError> {
-        let start = self.start_pos();
-        self.consume("<")?;
-        let name = self.read_tag_name();
-        self.push(TokenType::TagOpen, name, start);
-        self.mode = Mode::Tag;
-        Ok(())
-    }
-
-    fn read_closing_tag(&mut self) -> Result<(), CompileError> {
-        let start = self.start_pos();
-        self.consume("</")?;
-        let name = self.read_tag_name();
-        self.push(TokenType::TagOpenClose, name, start);
-        self.skip_whitespace();
-        if !self.eof() && self.peek() == Some('>') {
-            let close_start = self.start_pos();
-            self.consume(">")?;
-            self.push(TokenType::TagClose, ">".into(), close_start);
-        }
-        Ok(())
-    }
-
-    fn read_comment(&mut self) -> Result<(), CompileError> {
-        let start = self.start_pos();
-        self.consume("<!--")?;
-        let mut content = String::new();
-        while !self.eof() && !self.looking_at("-->") {
-            content.push(self.advance());
-        }
-        if self.eof() {
-            return Err(CompileError::new(
-                ErrorCode::MalformedComment,
-                Loc::new(start, self.start_pos()),
-                &self.source,
-                args!(),
-            ));
-        }
-        self.consume("-->")?;
-        self.push(TokenType::Comment, content.trim().to_string(), start);
-        Ok(())
-    }
-
-    fn read_mustache(&mut self) -> Result<(), CompileError> {
-        let open_start = self.start_pos();
-        self.consume("{{")?;
-        self.push(TokenType::MustacheOpen, "{{".into(), open_start);
-
-        let expr_start = self.start_pos();
-        let mut expr = String::new();
-        let mut depth = 0i32;
-        let mut in_str = false;
-        let mut str_char: Option<char> = None;
-
-        while !self.eof() {
-            let ch = self.peek().unwrap();
-
-            if in_str {
-                if ch == '\\' {
-                    expr.push(self.advance());
-                    if !self.eof() {
-                        expr.push(self.advance());
-                    }
-                    continue;
-                }
-                if Some(ch) == str_char {
-                    in_str = false;
-                }
-                expr.push(self.advance());
-                continue;
-            }
-
-            if ch == '"' || ch == '\'' || ch == '`' {
-                in_str = true;
-                str_char = Some(ch);
-                expr.push(self.advance());
-                continue;
-            }
-            if ch == '{' {
-                depth += 1;
-                expr.push(self.advance());
-                continue;
-            }
-            if ch == '}' {
-                if depth > 0 {
-                    depth -= 1;
-                    expr.push(self.advance());
-                    continue;
-                }
-                if self.peek_at(1) == Some('}') {
-                    self.push(TokenType::MustacheExpr, expr.trim().to_string(), expr_start);
-                    let close_start = self.start_pos();
-                    self.consume("}}")?;
-                    self.push(TokenType::MustacheClose, "}}".into(), close_start);
-                    return Ok(());
-                }
-            }
-
-            expr.push(self.advance());
-        }
-
-        Err(CompileError::new(
-            ErrorCode::UnterminatedMustache,
-            Loc::new(open_start, self.start_pos()),
-            &self.source,
-            args!(expr),
-        ))
-    }
-
-    fn read_in_tag(&mut self) -> Result<(), CompileError> {
-        self.skip_whitespace();
-        if self.eof() {
-            return Ok(());
-        }
-
-        if self.matches("/>") {
-            self.push(TokenType::TagSelfClose, "/>".into(), self.start_pos());
-            self.mode = Mode::Text;
-            return Ok(());
-        }
-
-        if self.peek() == Some('>') {
-            self.consume(">")?;
-            self.push(TokenType::TagClose, ">".into(), self.start_pos());
-            self.mode = Mode::Text;
-            return Ok(());
-        }
-
-        let start = self.start_pos();
-        let name = self.read_attr_name();
-        let name = match name {
-            Some(n) => n,
-            None => return Ok(()),
-        };
-
-        self.push(TokenType::AttrName, name, start);
-        self.skip_whitespace();
-
-        if self.peek() == Some('=') {
-            self.consume("=")?;
-            self.push(TokenType::AttrEquals, "=".into(), self.start_pos());
-            self.skip_whitespace();
-            self.read_attr_value();
-        }
-
-        Ok(())
-    }
-
-    fn read_attr_name(&mut self) -> Option<String> {
-        let mut name = String::new();
-
-        if self.peek() == Some('@') || self.peek() == Some(':') {
-            name.push(self.advance());
-        }
-
-        while !self.eof() {
-            let ch = self.peek().unwrap();
-            if ch.is_ascii_alphanumeric() || "-_.:".contains(ch) {
-                name.push(self.advance());
-            } else {
-                break;
-            }
-        }
-
-        if name.is_empty() {
-            None
-        } else {
-            Some(name)
-        }
-    }
-
-    fn read_attr_value(&mut self) {
-        if self.eof() {
-            return;
-        }
-        let quote = self.peek().unwrap();
-        if quote != '"' && quote != '\'' {
-            let start = self.start_pos();
-            let mut val = String::new();
-            while !self.eof() {
-                let ch = self.peek().unwrap();
-                if ch.is_whitespace() || ch == '>' {
-                    break;
-                }
-                val.push(self.advance());
-            }
-            self.push(TokenType::AttrValue, val, start);
-            return;
-        }
-
-        self.advance();
-        let start = self.start_pos();
-        let mut val = String::new();
-
-        while !self.eof() {
-            let ch = self.peek().unwrap();
-            if ch == quote {
-                self.advance();
-                break;
-            }
-            if ch == '\\' {
-                self.advance();
-                if !self.eof() {
-                    val.push(self.advance());
-                }
-                continue;
-            }
-            val.push(self.advance());
-        }
-
-        self.push(TokenType::AttrValue, val, start);
-    }
-
-    fn read_tag_name(&mut self) -> String {
-        let mut name = String::new();
-        while !self.eof() {
-            let ch = self.peek().unwrap();
-            if ch.is_ascii_alphanumeric() || "-_.".contains(ch) {
-                name.push(self.advance());
-            } else {
-                break;
-            }
-        }
-        name
-    }
-
-    fn is_tag_name_start(&self, ch: Option<char>) -> bool {
-        matches!(ch, Some(c) if c.is_ascii_alphabetic() || c == '_')
-    }
-
-
-    fn eof(&self) -> bool {
-        self.pos >= self.chars.len()
-    }
-
-    fn peek(&self) -> Option<char> {
-
-        self.chars.get(self.pos).copied()
-    }
-
-    fn peek_at(&self, n: usize) -> Option<char> {
-
-        self.chars.get(self.pos + n).copied()
-    }
-
-    fn looking_at(&self, s: &str) -> bool {
-        let s_chars: Vec<char> = s.chars().collect();
-        if self.pos + s_chars.len() > self.chars.len() {
-            return false;
-        }
-        self.chars[self.pos..self.pos + s_chars.len()] == s_chars[..]
-    }
-
-    fn matches(&mut self, s: &str) -> bool {
-        if self.looking_at(s) {
-            for _ in s.chars() {
-                self.advance();
-            }
-            true
-        } else {
-            false
-        }
-    }
-
-    fn consume(&mut self, expected: &str) -> Result<(), CompileError> {
-        for ch in expected.chars() {
-            if self.chars.get(self.pos) != Some(&ch) {
-                let found = self
-                    .chars
-                    .get(self.pos)
-                    .map(|c| c.to_string())
-                    .unwrap_or_default();
-                return Err(CompileError::new(
-                    ErrorCode::UnexpectedChar,
-                    Loc::new(self.start_pos(), self.start_pos()),
-                    &self.source,
-                    args!(found),
-                ));
-            }
-            self.advance();
-        }
-        Ok(())
-    }
-
-    fn advance(&mut self) -> char {
-        let ch = self.chars[self.pos];
-        self.pos += 1;
-        if ch == '\n' {
-            self.line += 1;
-            self.col = 1;
-        } else {
-            self.col += 1;
-        }
-        ch
-    }
-
-    fn skip_whitespace(&mut self) {
-        while !self.eof() && self.peek().map(|c| c.is_whitespace()).unwrap_or(false) {
-            self.advance();
-        }
-    }
-
-    fn start_pos(&self) -> Pos {
-        Pos::new(self.line, self.col, self.pos)
-    }
-
-    fn push(&mut self, ttype: TokenType, value: String, start: Pos) {
-        let loc = Loc::new(start, self.start_pos());
-        self.tokens.push(Token { ttype, value, loc });
-    }
-}

package/framework/core/rust-compiler/src/lib.rs

@@ -1,87 +0,0 @@
-#![allow(dead_code)]
-
-pub mod utils;
-pub mod errors;
-pub mod ast;
-pub mod generator;
-pub mod ssr_generator;
-pub mod lexer;
-pub mod main_compiler;
-pub mod parser;
-pub mod transformer;
-
-use serde::Deserialize;
-use wasm_bindgen::prelude::*;
-use crate::main_compiler::{CompileOptions, CompileTarget};
-
-// When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
-// allocator.
-#[cfg(feature = "wee_alloc")]
-#[global_allocator]
-static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
-
-#[wasm_bindgen]
-extern {
-    fn alert(s: &str);
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct RustCompileOptions {
-    #[serde(default)]
-    filename: Option<String>,
-    #[serde(default)]
-    components: Option<Vec<String>>,
-    #[serde(default)]
-    scope: Option<Vec<String>>,
-    #[serde(default)]
-    runtime_path: Option<String>,
-    #[serde(default)]
-    ssr_runtime_path: Option<String>,
-    #[serde(default)]
-    throw_on_warning: Option<bool>,
-    #[serde(default)]
-    target: Option<String>,
-}
-
-#[wasm_bindgen]
-pub fn compile(source: &str, options_json: &str) -> Result<String, JsValue> {
-    let opts: RustCompileOptions = serde_json::from_str(options_json)
-        .map_err(|e| JsValue::from_str(&format!("Invalid compiler options: {e}")))?;
-    let filename = opts.filename.clone().unwrap_or_else(|| "<template>".to_string());
-
-    let target = match opts.target.as_deref() {
-        Some("ssr") => CompileTarget::SSR,
-        Some("both") => CompileTarget::Both,
-        _ => CompileTarget::Client,
-    };
-
-    let compile_opts = CompileOptions {
-        filename: filename.clone(),
-        components: opts.components.unwrap_or_default().into_iter().collect(),
-        scope: opts.scope.unwrap_or_default().into_iter().collect(),
-        runtime_path: opts.runtime_path,
-        ssr_runtime_path: opts.ssr_runtime_path,
-        throw_on_warning: opts.throw_on_warning.unwrap_or(false),
-        target,
-    };
-
-    match main_compiler::compile(source, compile_opts) {
-        Ok(r) => {
-            let out = serde_json::json!({
-                "code": r.code,
-                "ssrCode": r.ssr_code,
-                "ast": r.ast,
-                "tokens": r.tokens,
-                "warnings": r.warnings,
-            });
-            serde_json::to_string(&out).map_err(|e| JsValue::from_str(&e.to_string()))
-        }
-        Err(e) => Err(JsValue::from_str(&e.format(&filename))),
-    }
-}
-
-#[wasm_bindgen]
-pub fn greet() {
-    alert("Hello, rust-compiler!");
-}

package/framework/core/rust-compiler/src/main_compiler.rs

@@ -1,165 +0,0 @@
-use crate::ast::Node;
-use crate::errors::{CompileError, CompileWarning};
-use crate::generator::{generate, GenerateOptions};
-use crate::lexer::{tokenize, Token};
-use crate::parser::parse;
-use crate::ssr_generator::{generate_ssr, SSRGenerateOptions};
-use crate::transformer::{transform, TransformOptions};
-use std::collections::HashSet;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum CompileTarget {
-    Client,
-    SSR,
-    Both,
-}
-
-impl Default for CompileTarget {
-    fn default() -> Self {
-        CompileTarget::Client
-    }
-}
-
-pub struct CompileOptions {
-    pub filename: String,
-    pub components: HashSet<String>,
-    pub scope: HashSet<String>,
-    pub runtime_path: Option<String>,
-    pub ssr_runtime_path: Option<String>,
-    pub throw_on_warning: bool,
-    pub target: CompileTarget,
-}
-
-impl Default for CompileOptions {
-    fn default() -> Self {
-        CompileOptions {
-            filename: "<template>".to_string(),
-            components: HashSet::new(),
-            scope: HashSet::new(),
-            runtime_path: None,
-            ssr_runtime_path: None,
-            throw_on_warning: false,
-            target: CompileTarget::Client,
-        }
-    }
-}
-
-pub struct CompileResult {
-    pub code: String,
-    pub ssr_code: Option<String>,
-    pub ast: Node,
-    pub tokens: Vec<Token>,
-    pub warnings: Vec<CompileWarning>,
-}
-
-pub fn compile(source: &str, options: CompileOptions) -> Result<CompileResult, CompileError> {
-    let tokens = tokenize(source).map_err(|e| rethrow(e, &options.filename))?;
-
-    let ast = parse(tokens.clone(), source, &options.components)
-        .map_err(|e| rethrow(e, &options.filename))?;
-
-    let transform_opts = TransformOptions {
-        components: options.components.clone(),
-        source: source.to_string(),
-        scope: options.scope.clone(),
-    };
-    let (ast, warnings) = transform(ast, transform_opts);
-
-    if options.throw_on_warning {
-        if let Some(w) = warnings.first() {
-            return Err(CompileError::new(w.code, w.loc.clone(), source, &[]));
-        }
-    }
-
-    let root = match &ast {
-        Node::Root(r) => r,
-        _ => unreachable!("parse() always produces a Root node"),
-    };
-
-    let code: String;
-    let mut ssr_code: Option<String> = None;
-
-    match options.target {
-        CompileTarget::Client => {
-            code = generate(
-                root,
-                GenerateOptions {
-                    source: source.to_string(),
-                    runtime_path: options.runtime_path.clone(),
-                },
-            )
-            .map_err(|e| rethrow(e, &options.filename))?;
-        }
-        CompileTarget::SSR => {
-            let ssr = generate_ssr(
-                root,
-                SSRGenerateOptions {
-                    source: source.to_string(),
-                    runtime_path: options
-                        .ssr_runtime_path
-                        .clone()
-                        .or_else(|| options.runtime_path.clone()),
-                },
-            )
-            .map_err(|e| rethrow(e, &options.filename))?;
-            code = ssr.clone();
-            ssr_code = Some(ssr);
-        }
-        CompileTarget::Both => {
-            code = generate(
-                root,
-                GenerateOptions {
-                    source: source.to_string(),
-                    runtime_path: options.runtime_path.clone(),
-                },
-            )
-            .map_err(|e| rethrow(e, &options.filename))?;
-
-            let ssr = generate_ssr(
-                root,
-                SSRGenerateOptions {
-                    source: source.to_string(),
-                    runtime_path: options
-                        .ssr_runtime_path
-                        .clone()
-                        .or_else(|| options.runtime_path.clone()),
-                },
-            )
-            .map_err(|e| rethrow(e, &options.filename))?;
-            ssr_code = Some(ssr);
-        }
-    }
-
-    Ok(CompileResult {
-        code,
-        ssr_code,
-        ast,
-        tokens,
-        warnings,
-    })
-}
-
-pub fn parse_only(source: &str, components: &HashSet<String>) -> Result<(Node, Vec<Token>), CompileError> {
-    let tokens = tokenize(source)?;
-    let ast = parse(tokens.clone(), source, components)?;
-    Ok((ast, tokens))
-}
-
-pub fn transform_only(ast: Node, components: HashSet<String>, source: String, scope: HashSet<String>) -> (Node, Vec<CompileWarning>) {
-    transform(
-        ast,
-        TransformOptions {
-            components,
-            source,
-            scope,
-        },
-    )
-}
-
-fn rethrow(err: CompileError, filename: &str) -> CompileError {
-    let formatted = err.format(filename);
-    CompileError {
-        message: formatted,
-        ..err
-    }
-}