fusee-framework 2.7.0 → 2.7.1

package/framework/core/rust-compiler/pkg/fusee_compiler_bg.js

@@ -1,137 +0,0 @@
-/**
- * @param {string} source
- * @param {string} options_json
- * @returns {string}
- */
-export function compile(source, options_json) {
-    let deferred4_0;
-    let deferred4_1;
-    try {
-        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.compile(ptr0, len0, ptr1, len1);
-        var ptr3 = ret[0];
-        var len3 = ret[1];
-        if (ret[3]) {
-            ptr3 = 0; len3 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred4_0 = ptr3;
-        deferred4_1 = len3;
-        return getStringFromWasm0(ptr3, len3);
-    } finally {
-        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
-    }
-}
-
-export function greet() {
-    wasm.greet();
-}
-export function __wbg_alert_f3c04f14b1e59052(arg0, arg1) {
-    alert(getStringFromWasm0(arg0, arg1));
-}
-export function __wbindgen_generic_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Ref(String) -> Externref`.
-    const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
-}
-export function __wbindgen_init_externref_table() {
-    const table = wasm.__wbindgen_externrefs;
-    const offset = table.grow(4);
-    table.set(0, undefined);
-    table.set(offset + 0, undefined);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
-}
-function getStringFromWasm0(ptr, len) {
-    return decodeText(ptr >>> 0, len);
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    };
-}
-
-let WASM_VECTOR_LEN = 0;
-
-
-let wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}

package/framework/core/rust-compiler/pkg/fusee_compiler_bg.wasm.d.ts

@@ -1,11 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export const memory: WebAssembly.Memory;
-export const compile: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-export const greet: () => void;
-export const __wbindgen_externrefs: WebAssembly.Table;
-export const __wbindgen_malloc: (a: number, b: number) => number;
-export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-export const __externref_table_dealloc: (a: number) => void;
-export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __wbindgen_start: () => void;

package/framework/core/rust-compiler/pkg/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "fusee-compiler",
-  "type": "module",
-  "description": "Fusée template compiler — lexer/parser/transformer/generator — Rust+WASM port",
-  "version": "0.1.0",
-  "files": [
-    "fusee_compiler_bg.wasm",
-    "fusee_compiler.js",
-    "fusee_compiler_bg.js",
-    "fusee_compiler.d.ts"
-  ],
-  "main": "fusee_compiler.js",
-  "types": "fusee_compiler.d.ts",
-  "sideEffects": [
-    "./fusee_compiler.js",
-    "./snippets/*"
-  ]
-}

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

@@ -1,274 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-pub type NodeId = usize;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-pub struct Pos {
-    pub line: usize,
-    pub col: usize,
-    pub offset: usize,
-}
-
-impl Pos {
-    pub fn new(line: usize, col: usize, offset: usize) -> Self {
-        Pos { line, col, offset }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
-pub struct Loc {
-    pub start: Pos,
-    pub end: Pos,
-}
-
-impl Loc {
-    pub fn new(start: Pos, end: Pos) -> Self {
-        Loc { start, end }
-    }
-    pub fn point(p: Pos) -> Self {
-        Loc { start: p, end: p }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Expression {
-    pub content: String,
-    pub is_static: bool,
-    pub is_for_key: bool,
-    pub loc: Loc,
-}
-
-impl Expression {
-    pub fn new(content: impl Into<String>, is_static: bool, loc: Loc) -> Self {
-        Expression {
-            content: content.into(),
-            is_static,
-            is_for_key: false,
-            loc,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AttributeNode {
-    pub name: String,
-    pub value: Option<String>,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BindingNode {
-    pub name: String,
-    pub expression: Expression,
-    pub is_prop: bool,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct EventNode {
-    pub name: String,
-    pub expression: Expression,
-    pub modifiers: Vec<String>,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ForArg {
-    pub item: String,
-    pub source: String,
-    pub index: Option<String>,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DirectiveNode {
-    pub name: String,
-    pub expression: Option<Expression>,
-    pub arg: Option<ForArg>,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum Prop {
-    Attribute(AttributeNode),
-    Binding(BindingNode),
-    Event(EventNode),
-    Directive(DirectiveNode),
-}
-
-impl Prop {
-    pub fn loc(&self) -> &Loc {
-        match self {
-            Prop::Attribute(a) => &a.loc,
-            Prop::Binding(b) => &b.loc,
-            Prop::Event(e) => &e.loc,
-            Prop::Directive(d) => &d.loc,
-        }
-    }
-
-    pub fn as_directive(&self) -> Option<&DirectiveNode> {
-        match self {
-            Prop::Directive(d) => Some(d),
-            _ => None,
-        }
-    }
-
-    pub fn as_binding(&self) -> Option<&BindingNode> {
-        match self {
-            Prop::Binding(b) => Some(b),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Branch {
-    pub condition: Option<Expression>,
-    pub node: Box<Node>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ElementNode {
-    pub id: NodeId,
-    pub tag: String,
-    pub props: Vec<Prop>,
-    pub children: Vec<Node>,
-    pub self_closing: bool,
-    pub is_static: bool,
-    pub hoisted: bool,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ComponentNode {
-    pub id: NodeId,
-    pub name: String,
-    pub props: Vec<Prop>,
-    pub slots: Vec<(String, Vec<Node>)>,
-    pub loc: Loc,
-}
-
-impl ComponentNode {
-    pub fn slot(&self, name: &str) -> Option<&Vec<Node>> {
-        self.slots.iter().find(|(n, _)| n == name).map(|(_, c)| c)
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TextNode {
-    pub content: String,
-    pub is_static: bool,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct InterpolationNode {
-    pub expression: Expression,
-    pub is_static: bool,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SlotOutletNode {
-    pub slot_name: String,
-    pub fallback: Vec<Node>,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SlotContentNode {
-    pub slot_name: String,
-    pub children: Vec<Node>,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct IfNode {
-    pub branches: Vec<Branch>,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RootNode {
-    pub children: Vec<Node>,
-    pub hoisted: Vec<NodeId>,
-    pub loc: Loc,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum Node {
-    Root(RootNode),
-    Element(ElementNode),
-    Component(ComponentNode),
-    Text(TextNode),
-    Interpolation(InterpolationNode),
-    SlotOutlet(SlotOutletNode),
-    SlotContent(SlotContentNode),
-    If(IfNode),
-}
-
-impl Node {
-    pub fn loc(&self) -> &Loc {
-        match self {
-            Node::Root(n) => &n.loc,
-            Node::Element(n) => &n.loc,
-            Node::Component(n) => &n.loc,
-            Node::Text(n) => &n.loc,
-            Node::Interpolation(n) => &n.loc,
-            Node::SlotOutlet(n) => &n.loc,
-            Node::SlotContent(n) => &n.loc,
-            Node::If(n) => &n.loc,
-        }
-    }
-
-    pub fn is_element(&self) -> bool {
-        matches!(self, Node::Element(_))
-    }
-    pub fn is_component(&self) -> bool {
-        matches!(self, Node::Component(_))
-    }
-    pub fn is_element_or_component(&self) -> bool {
-        self.is_element() || self.is_component()
-    }
-
-    pub fn props(&self) -> Option<&Vec<Prop>> {
-        match self {
-            Node::Element(n) => Some(&n.props),
-            Node::Component(n) => Some(&n.props),
-            _ => None,
-        }
-    }
-
-    pub fn children(&self) -> Option<&Vec<Node>> {
-        match self {
-            Node::Root(n) => Some(&n.children),
-            Node::Element(n) => Some(&n.children),
-            _ => None,
-        }
-    }
-
-    pub fn find_directive(&self, name: &str) -> Option<&DirectiveNode> {
-        self.props()?
-            .iter()
-            .find_map(|p| p.as_directive().filter(|d| d.name == name))
-    }
-
-    pub fn tag_or_name(&self) -> &str {
-        match self {
-            Node::Element(n) => &n.tag,
-            Node::Component(n) => &n.name,
-            _ => "",
-        }
-    }
-
-    pub fn set_is_static(&mut self, v: bool) {
-        match self {
-            Node::Element(n) => n.is_static = v,
-            Node::Text(n) => n.is_static = v,
-            Node::Interpolation(n) => n.is_static = v,
-            _ => {}
-        }
-    }
-}

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

@@ -1,204 +0,0 @@
-use crate::ast::Loc;
-use once_cell::sync::Lazy;
-use regex::Regex;
-use serde::{Deserialize, Serialize};
-
-#[macro_export]
-macro_rules! args {
-    () => { Vec::new() };
-    ($($e:expr),+ $(,)?) => { vec![$($e.to_string()),+] };
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub enum ErrorCode {
-    UnexpectedChar,
-    UnterminatedString,
-    UnterminatedMustache,
-    UnterminatedTag,
-    MalformedComment,
-    UnexpectedToken,
-    MissingClosingTag,
-    UnexpectedClosingTag,
-    InvalidDirectiveSyntax,
-    InvalidForSyntax,
-    DuplicateKey,
-    VElseNoIf,
-    EmptyExpression,
-    InvalidSlotName,
-    DuplicateDirective,
-    ForMissingKey,
-    ModelOnNonInput,
-    ComponentNotRegistered,
-    UnknownIdentifier,
-    StaticForKey,
-    UnknownNodeType,
-}
-
-impl ErrorCode {
-    pub fn as_str(self) -> &'static str {
-        match self {
-            ErrorCode::UnexpectedChar => "E001",
-            ErrorCode::UnterminatedString => "E002",
-            ErrorCode::UnterminatedMustache => "E003",
-            ErrorCode::UnterminatedTag => "E004",
-            ErrorCode::MalformedComment => "E005",
-            ErrorCode::UnexpectedToken => "P001",
-            ErrorCode::MissingClosingTag => "P002",
-            ErrorCode::UnexpectedClosingTag => "P003",
-            ErrorCode::InvalidDirectiveSyntax => "P004",
-            ErrorCode::InvalidForSyntax => "P005",
-            ErrorCode::DuplicateKey => "P006",
-            ErrorCode::VElseNoIf => "P007",
-            ErrorCode::EmptyExpression => "P008",
-            ErrorCode::InvalidSlotName => "P009",
-            ErrorCode::DuplicateDirective => "T001",
-            ErrorCode::ForMissingKey => "T002",
-            ErrorCode::ModelOnNonInput => "T003",
-            ErrorCode::ComponentNotRegistered => "T004",
-            ErrorCode::UnknownIdentifier => "S001",
-            ErrorCode::StaticForKey => "S002",
-            ErrorCode::UnknownNodeType => "G001",
-        }
-    }
-}
-
-fn template_for(code: ErrorCode) -> &'static str {
-    match code {
-        ErrorCode::UnexpectedChar => "Unexpected character \"{0}\"",
-        ErrorCode::UnterminatedString => "Unterminated string literal",
-        ErrorCode::UnterminatedMustache => "Unterminated mustache expression \"{0}\"",
-        ErrorCode::UnterminatedTag => "Unterminated tag \"<{0}\"",
-        ErrorCode::MalformedComment => "Malformed HTML comment",
-        ErrorCode::UnexpectedToken => "Unexpected token \"{0}\", expected \"{1}\"",
-        ErrorCode::MissingClosingTag => "Missing closing tag for <{0}>",
-        ErrorCode::UnexpectedClosingTag => "Unexpected closing tag </{0}>",
-        ErrorCode::InvalidDirectiveSyntax => "Invalid directive syntax: \"{0}\"",
-        ErrorCode::InvalidForSyntax => {
-            "Invalid f-for syntax: \"{0}\". Expected \"(item, index) in source\" or \"item in source\""
-        }
-        ErrorCode::DuplicateKey => "Duplicate attribute \"{0}\" on element <{1}>",
-        ErrorCode::VElseNoIf => "f-else / f-else-if has no matching f-if",
-        ErrorCode::EmptyExpression => "Expression in \"{0}\" must not be empty",
-        ErrorCode::InvalidSlotName => "Invalid slot name \"{0}\"",
-        ErrorCode::DuplicateDirective => "Duplicate directive \"f-{0}\" on element <{1}>",
-        ErrorCode::ForMissingKey => {
-            "f-for on <{0}> is missing a :key binding — add :key=\"<unique expr>\""
-        }
-        ErrorCode::ModelOnNonInput => {
-            "f-model can only be used on <input>, <textarea> or <select>, got <{0}>"
-        }
-        ErrorCode::ComponentNotRegistered => {
-            "Component \"{0}\" is used in the template but not registered"
-        }
-        ErrorCode::UnknownIdentifier => {
-            "Unknown identifier \"{0}\" in expression \"{1}\" — not found in component scope"
-        }
-        ErrorCode::StaticForKey => {
-            ":key=\"{0}\" is a static literal — keys must be unique per item (use a dynamic expression like :key=\"item.id\")"
-        }
-        ErrorCode::UnknownNodeType => "Unknown AST node type \"{0}\" encountered in generator",
-    }
-}
-
-static PLACEHOLDER_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\{(\d+)\}").unwrap());
-
-fn interpolate(template: &str, args: &[String]) -> String {
-    PLACEHOLDER_RE
-        .replace(template, |caps: &regex::Captures| {
-            let idx: usize = caps[1].parse().unwrap_or(0);
-            args.get(idx).map(|s| s.as_str()).unwrap_or("")
-        })
-        .into_owned()
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct CompileError {
-    pub message: String,
-    pub code: ErrorCode,
-    pub loc: Loc,
-    pub source: String,
-}
-
-impl CompileError {
-    pub fn new(code: ErrorCode, loc: Loc, source: &str, args: impl AsRef<[String]>, ) -> Self {
-        let template = template_for(code);
-        let message = interpolate(template, args.as_ref());
-        CompileError {
-            message,
-            code,
-            loc,
-            source: source.to_string(),
-        }
-    }
-
-    pub fn format(&self, file_path: &str) -> String {
-        let start = &self.loc.start;
-        let header = format!("[fusée] CompileError {} at {}:{}:{}", self.code.as_str(), file_path, start.line, start.col);
-        let snippet = self.build_snippet();
-        if snippet.is_empty() {
-            format!("{header}\n{}", self.message)
-        } else {
-            format!("{header}\n{}\n\n{snippet}", self.message)
-        }
-    }
-
-    fn build_snippet(&self) -> String {
-        if self.source.is_empty() || self.loc.start.line == 0 {
-            return String::new();
-        }
-        let lines: Vec<&str> = self.source.split('\n').collect();
-        let line_idx = self.loc.start.line - 1;
-        if line_idx >= lines.len() {
-            return String::new();
-        }
-        let col = self.loc.start.col;
-        let context = 2;
-        let first_line = line_idx.saturating_sub(context);
-        let last_line = (line_idx + context).min(lines.len() - 1);
-        let width = (last_line + 1).to_string().len();
-
-        let mut parts: Vec<String> = Vec::new();
-        for i in first_line..=last_line {
-            let line_no = format!("{:width$}", i + 1, width = width);
-            let prefix = if i == line_idx { "> " } else { "  " };
-            parts.push(format!("{prefix}{line_no} | {}", lines[i]));
-            if i == line_idx {
-                let caret_pad = " ".repeat(width + 4 + col.saturating_sub(1));
-                let end_col = if self.loc.end.col > 0 {
-                    self.loc.end.col
-                } else {
-                    col
-                };
-                let caret_len = end_col.saturating_sub(col).max(1);
-                parts.push(format!("{caret_pad}{}", "~".repeat(caret_len)));
-            }
-        }
-        parts.join("\n")
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct CompileWarning {
-    pub message: String,
-    pub code: ErrorCode,
-    pub loc: Loc,
-    pub source: String,
-}
-
-impl CompileWarning {
-    pub fn new(code: ErrorCode, loc: Loc, source: &str, args: impl AsRef<[String]>) -> Self {
-        let template = template_for(code);
-        let message = interpolate(template, args.as_ref());
-        CompileWarning {
-            message,
-            code,
-            loc,
-            source: source.to_string(),
-        }
-    }
-
-    pub fn format(&self, file_path: &str) -> String {
-        let start = &self.loc.start;
-        format!("[fusée] Warning {} at {}:{}:{}\n{}", self.code.as_str(), file_path, start.line, start.col, self.message)
-    }
-}