onelaraveljs 1.0.0 → 1.1.3

package/scripts/compiler/binding_directive_service.py

@@ -0,0 +1,103 @@
+"""
+Binding Directive Service - Xử lý @val và @bind directives
+@val và @bind là alias của nhau, cùng tạo ra data-binding attribute
+"""
+
+import re
+
+class BindingDirectiveService:
+    def __init__(self):
+        pass
+    
+    def process_binding_directive(self, content, directive_pattern='val|bind'):
+        """
+        Process binding directives (@val and @bind are aliases)
+        @val($userState->name) -> data-binding="userState.name"
+        @bind($username) -> data-binding="username"
+        Both directives produce the same output
+        """
+        def replace_binding_with_nested_parens(content):
+            result = content
+            while True:
+                # Find @val or @bind directive
+                match = re.search(rf'@({directive_pattern})\s*\(', result)
+                if not match:
+                    break
+                
+                start_pos = match.end() - 1  # Position of opening (
+                paren_count = 0
+                i = start_pos
+                
+                # Find matching closing parenthesis
+                while i < len(result):
+                    if result[i] == '(':
+                        paren_count += 1
+                    elif result[i] == ')':
+                        paren_count -= 1
+                        if paren_count == 0:
+                            # Found matching closing parenthesis
+                            expression = result[start_pos + 1:i].strip()
+                            binding_value = self._convert_php_to_binding(expression)
+                            replacement = f'data-binding="{binding_value}" data-view-id="${{__VIEW_ID__}}"'
+                            result = result[:match.start()] + replacement + result[i + 1:]
+                            break
+                    i += 1
+                else:
+                    # No matching parenthesis found, break to avoid infinite loop
+                    break
+            
+            return result
+        
+        return replace_binding_with_nested_parens(content)
+    
+    def process_val_directive(self, content):
+        """
+        Process @val directive (alias of process_binding_directive)
+        @val($userState->name) -> data-binding="userState.name"
+        @val($user['name']) -> data-binding="user.name"
+        """
+        return self.process_binding_directive(content, 'val')
+    
+    def process_bind_directive(self, content):
+        """
+        Process @bind directive (alias of process_binding_directive)
+        @bind($username) -> data-binding="username"
+        """
+        return self.process_binding_directive(content, 'bind')
+    
+    def _convert_php_to_binding(self, php_expression):
+        """
+        Convert PHP expression to JavaScript binding notation
+        $userState->name -> userState.name
+        $user['name'] -> user.name
+        $username -> username
+        User::find($id)->profile->displayName -> User.find(id).profile.displayName
+        """
+        # Remove leading/trailing whitespace
+        php_expression = php_expression.strip()
+        
+        # Convert $variable to variable (remove $ prefix)
+        result = re.sub(r'\$([a-zA-Z_][a-zA-Z0-9_]*)', r'\1', php_expression)
+        
+        # Convert PHP static method accessor (::) to (.)
+        result = re.sub(r'::', '.', result)
+        
+        # Convert object accessor (->) to (.)
+        result = re.sub(r'->', '.', result)
+        
+        # Convert array access ['key'] to .key
+        result = re.sub(r"\['([^']+)'\]", r'.\1', result)
+        result = re.sub(r'\["([^"]+)"\]', r'.\1', result)
+        
+        # Convert numeric array access [0] to .0 (though this is less common)
+        result = re.sub(r'\[(\d+)\]', r'.\1', result)
+        
+        return result
+    
+    def process_all_binding_directives(self, content):
+        """
+        Process both @val and @bind directives in content (they are aliases)
+        This method processes both directives in a single pass
+        """
+        # Process both @val and @bind directives together (they are aliases)
+        return self.process_binding_directive(content, 'val|bind')

package/scripts/compiler/class_binding_handler.py

@@ -0,0 +1,347 @@
+"""
+Class Binding Handler - Xử lý @class directive
+Supports: static classes, conditional classes, và mixed binding
+Uses separate __classBinding() method for reactive class management
+"""
+
+import re
+from php_js_converter import php_to_js_advanced
+
+class ClassBindingHandler:
+    def __init__(self, state_variables=None):
+        self.state_variables = state_variables or set()
+    
+    def process_class_directive(self, content):
+        """
+        Process @class directive with multiple formats:
+        1. @class('static-class') - static class
+        2. @class('class', $condition) - conditional class  
+        3. @class(['class1' => $cond1, 'class2' => $cond2]) - array binding
+        4. @class(['static', 'dynamic' => $cond]) - mixed
+        
+        Multiple @class on same line will be merged into one
+        
+        Output format:
+        - Static only: class="static-class"
+        - With dynamic: ${this.__classBinding([...])}
+        
+        Note: Supports multi-line directives within HTML tag attributes
+        """
+        result = content
+        
+        # Process all @class directives globally (supports multi-line)
+        while True:
+            match = re.search(r'@class\s*\(', result)
+            if not match:
+                break
+            
+            # Find matching closing parenthesis (can span multiple lines)
+            start_pos = match.end() - 1
+            paren_count = 0
+            i = start_pos
+            
+            while i < len(result):
+                if result[i] == '(':
+                    paren_count += 1
+                elif result[i] == ')':
+                    paren_count -= 1
+                    if paren_count == 0:
+                        # Found complete directive
+                        expression = result[start_pos + 1:i].strip()
+                        replacement = self._generate_class_output(expression)
+                        result = result[:match.start()] + replacement + result[i + 1:]
+                        break
+                i += 1
+            else:
+                # No matching closing paren found - skip this one
+                break
+        
+        return result
+    
+    def _merge_multiple_class_directives(self, line):
+        """
+        Merge multiple @class directives on the same line into one
+        """
+        all_bindings = []
+        
+        # Extract all @class expressions
+        while True:
+            match = re.search(r'@class\s*\(', line)
+            if not match:
+                break
+            
+            start_pos = match.end() - 1
+            paren_count = 0
+            i = start_pos
+            
+            # Find matching closing parenthesis
+            while i < len(line):
+                if line[i] == '(':
+                    paren_count += 1
+                elif line[i] == ')':
+                    paren_count -= 1
+                    if paren_count == 0:
+                        expression = line[start_pos + 1:i].strip()
+                        bindings = self._parse_class_expression(expression)
+                        all_bindings.extend(bindings)
+                        # Remove this @class directive
+                        line = line[:match.start()] + line[i + 1:]
+                        break
+                i += 1
+            else:
+                break
+        
+        # Generate single output for all merged bindings
+        if all_bindings:
+            replacement = self._generate_output_from_bindings(all_bindings)
+            # Insert at the first @class position (which is now gone)
+            # Find a good insertion point - before the first > or at the start
+            insertion_point = line.find('>')
+            if insertion_point > 0:
+                line = line[:insertion_point] + ' ' + replacement + line[insertion_point:]
+            else:
+                line = line + ' ' + replacement
+        
+        return line
+    
+    def _process_single_class_directive(self, line):
+        """
+        Process a single @class directive on a line
+        """
+        match = re.search(r'@class\s*\(', line)
+        if not match:
+            return line
+        
+        start_pos = match.end() - 1
+        paren_count = 0
+        i = start_pos
+        
+        while i < len(line):
+            if line[i] == '(':
+                paren_count += 1
+            elif line[i] == ')':
+                paren_count -= 1
+                if paren_count == 0:
+                    expression = line[start_pos + 1:i].strip()
+                    replacement = self._generate_class_output(expression)
+                    line = line[:match.start()] + replacement + line[i + 1:]
+                    break
+            i += 1
+        
+        return line
+    
+    def _generate_class_output(self, expression):
+        """
+        Generate output for class directive
+        Returns either static class="..." or ${this.__attr({"class": {...}})}
+        """
+        bindings = self._parse_class_expression(expression)
+        return self._generate_output_from_bindings(bindings)
+    
+    def _generate_output_from_bindings(self, bindings):
+        """
+        Generate output from a list of bindings
+        Returns either static class="..." or ${this.__classBinding([...])}
+        """
+        # Check if all bindings are static
+        has_dynamic = any(b['type'] == 'binding' for b in bindings)
+        
+        if not has_dynamic:
+            # All static - output direct class attribute
+            static_classes = [b['value'] for b in bindings]
+            return f'class="{" ".join(static_classes)}"'
+        else:
+            # Has dynamic - use __classBinding
+            return self._generate_class_binding_config(bindings)
+    
+    def _generate_class_binding_config(self, bindings):
+        """
+        Generate __classBinding() config
+        Format: ${this.__classBinding([{type: "static", value: "...", states: [...], checker: () => ...}])}
+        """
+        binding_configs = []
+        
+        for binding in bindings:
+            if binding['type'] == 'static':
+                binding_configs.append(f'{{type: "static", value: "{binding["value"]}"}}')
+            elif binding['type'] == 'binding':
+                states = binding.get('states', [])
+                states_str = ', '.join([f'"{s}"' for s in states])
+                checker = binding['checker']
+                class_name = binding['value']
+                binding_configs.append(f'{{type: "binding", value: "{class_name}", states: [{states_str}], checker: () => {checker}}}')
+        
+        configs_joined = ', '.join(binding_configs)
+        return f'${{this.__classBinding([{configs_joined}])}}'
+    
+    def _parse_class_expression(self, expression):
+        """
+        Parse class expression and return list of binding dicts
+        Returns: [{"type": "static"|"binding", "value": "class-name", ...}, ...]
+        """
+        expression = expression.strip()
+        
+        # Case 1: Simple string - @class('class')
+        if self._is_simple_string(expression):
+            class_name = self._extract_string_value(expression)
+            return [{"type": "static", "value": class_name}]
+        
+        # Case 2: Two arguments - @class('class', $condition)
+        if ',' in expression and not expression.startswith('['):
+            parts = self._split_arguments(expression)
+            if len(parts) == 2:
+                class_name = self._extract_string_value(parts[0].strip())
+                condition = parts[1].strip()
+                states = self._extract_state_variables(condition)
+                js_condition = self._convert_php_to_js(condition)
+                return [{
+                    "type": "binding",
+                    "value": class_name,
+                    "states": states,
+                    "checker": js_condition
+                }]
+        
+        # Case 3: Array format - @class(['class1' => $cond, 'class2'])
+        if expression.startswith('[') and expression.endswith(']'):
+            return self._parse_array_expression(expression)
+        
+        # Fallback: treat as static class
+        return [{"type": "static", "value": expression}]
+    
+    def _parse_array_expression(self, expression):
+        """
+        Parse array expression: ['class1' => $cond, 'static', 'class2' => $cond2]
+        Returns list of binding dicts
+        """
+        # Remove outer brackets
+        inner = expression[1:-1].strip()
+        
+        # Split by comma, but respect nested structures
+        items = self._split_array_items(inner)
+        
+        bindings = []
+        for item in items:
+            item = item.strip()
+            if not item:
+                continue
+            
+            # Check if it's a key => value pair
+            if '=>' in item:
+                parts = item.split('=>', 1)
+                class_name = self._extract_string_value(parts[0].strip())
+                condition = parts[1].strip()
+                
+                # Check if condition is a static string
+                if self._is_simple_string(condition):
+                    # Static value like 'demo' => 'dump'
+                    static_value = self._extract_string_value(condition)
+                    bindings.append({"type": "static", "value": static_value})
+                else:
+                    # Dynamic condition
+                    states = self._extract_state_variables(condition)
+                    js_condition = self._convert_php_to_js(condition)
+                    bindings.append({
+                        "type": "binding",
+                        "value": class_name,
+                        "states": states,
+                        "checker": js_condition
+                    })
+            else:
+                # Static class without condition
+                class_name = self._extract_string_value(item)
+                bindings.append({"type": "static", "value": class_name})
+        
+        return bindings
+    
+    def _split_array_items(self, content):
+        """
+        Split array items by comma, respecting nested structures
+        """
+        items = []
+        current = []
+        depth = 0
+        in_string = False
+        string_char = None
+        i = 0
+        
+        while i < len(content):
+            char = content[i]
+            
+            # Handle string boundaries
+            if char in ('"', "'") and (i == 0 or content[i-1] != '\\'):
+                if not in_string:
+                    in_string = True
+                    string_char = char
+                elif char == string_char:
+                    in_string = False
+                    string_char = None
+            
+            # Handle nested structures
+            if not in_string:
+                if char in '([{':
+                    depth += 1
+                elif char in ')]}':
+                    depth -= 1
+                elif char == ',' and depth == 0:
+                    items.append(''.join(current))
+                    current = []
+                    i += 1
+                    continue
+            
+            current.append(char)
+            i += 1
+        
+        if current:
+            items.append(''.join(current))
+        
+        return items
+    
+    def _split_arguments(self, expression):
+        """
+        Split function arguments by comma, respecting nested structures
+        """
+        return self._split_array_items(expression)
+    
+    def _is_simple_string(self, expression):
+        """
+        Check if expression is a simple quoted string
+        """
+        expression = expression.strip()
+        return (expression.startswith("'") and expression.endswith("'")) or \
+               (expression.startswith('"') and expression.endswith('"'))
+    
+    def _extract_string_value(self, expression):
+        """
+        Extract string value from quoted string
+        'class' -> class
+        "class" -> class
+        """
+        expression = expression.strip()
+        if (expression.startswith("'") and expression.endswith("'")) or \
+           (expression.startswith('"') and expression.endswith('"')):
+            return expression[1:-1]
+        return expression
+    
+    def _extract_state_variables(self, php_expression):
+        """
+        Extract state variable names from PHP expression
+        $abc -> abc
+        $abc->test($cde) -> abc, cde
+        $demo && !$on || !$r->e -> demo, on, r
+        """
+        # Find all $variable patterns
+        variables = set()
+        matches = re.findall(r'\$([a-zA-Z_][a-zA-Z0-9_]*)', php_expression)
+        for var in matches:
+            # Only include if it's a state variable
+            if var in self.state_variables or True:  # Include all for now
+                variables.add(var)
+        
+        return sorted(list(variables))
+    
+    def _convert_php_to_js(self, php_expression):
+        """
+        Convert PHP expression to JavaScript
+        Uses the existing php_to_js_advanced function
+        """
+        return php_to_js_advanced(php_expression)

package/scripts/compiler/cli.py

@@ -0,0 +1,34 @@
+"""
+Command line interface cho Blade Compiler
+"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from main_compiler import BladeCompiler
+
+def main():
+    if len(sys.argv) < 3:
+        print("Sử dụng: python cli.py <input.blade> <output.js>")
+        sys.exit(1)
+    
+    input_file = sys.argv[1]
+    output_file = sys.argv[2]
+    
+    try:
+        with open(input_file, 'r', encoding='utf-8') as f:
+            blade_code = f.read()
+        
+        compiler = BladeCompiler()
+        js_code = compiler.compile_blade_to_js(blade_code, 'test')
+        
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(js_code)
+        
+        print(f"Đã compile thành công từ {input_file} sang {output_file}")
+    except Exception as e:
+        print(f"Lỗi: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/scripts/compiler/code_generator.py

@@ -0,0 +1,141 @@
+"""
+Generator cho JavaScript code output
+"""
+
+import json
+import re
+from config import JS_FUNCTION_PREFIX, HTML_ATTR_PREFIX
+from variables_analyzer import analyze_render_uses_vars, analyze_sections_info
+
+def generate_prerender(has_await, has_fetch, extended_view, sections_code, template_content, vars_line, view_id_line, output_content_line="", uses_vars=True, sections_info=None):
+    """Generate prerender function based on @await or @fetch directive presence"""
+    if sections_info is None:
+        sections_info = {}
+    
+    if not has_await and not has_fetch and not sections_code:
+        return "function(__$spaViewData$__ = {}) {\n    return null;\n}"
+    
+    if not uses_vars and not sections_info:
+        return "function(__$spaViewData$__ = {}) {\n    return null;\n}"
+    
+    if not has_await and not has_fetch and not vars_line:
+        return "function(__$spaViewData$__ = {}) {\n    return null;\n}"
+    
+    # Initialize prerender_sections
+    prerender_sections = []
+    
+    if sections_info:
+        # Process sections based on their configuration
+        for section_name, section_info in sections_info.items():
+            section_type = section_info.get("type", "short")
+            preloader = section_info.get("preloader", False)
+            use_vars = section_info.get("useVars", False)
+            
+            if section_type == "long" and not use_vars:
+                # Long section không dùng biến - render trực tiếp trong prerender
+                # Không cần đợi fetch/await vì không dùng dynamic data
+                section_pattern = f'{JS_FUNCTION_PREFIX}\.section\(\'{section_name}\',[^)]+\)'
+                section_match = re.search(section_pattern, sections_code, re.DOTALL)
+                if section_match:
+                    prerender_sections.append("${" + section_match.group(0) + "}")
+            elif section_type == "short" and not use_vars:
+                # Short section không dùng biến - render trực tiếp trong prerender
+                section_pattern = f'{JS_FUNCTION_PREFIX}\.section\(\'{section_name}\',[^)]+\)'
+                section_match = re.search(section_pattern, sections_code, re.DOTALL)
+                if section_match:
+                    prerender_sections.append("${" + section_match.group(0) + "}")
+            elif preloader:
+                # Section có preloader (dùng biến + có fetch/await) - tạo section preloader
+                prerender_sections.append("${" + JS_FUNCTION_PREFIX + ".section('" + section_name + "', `<div class=\"" + HTML_ATTR_PREFIX + "preloader\" ref=\"${__VIEW_ID__}\" data-section-name=\"" + section_name + "\">${" + JS_FUNCTION_PREFIX + ".text('loading')}</div>`)}")
+    
+    # Generate function based on context
+    if extended_view:
+        if has_await or has_fetch:
+            return f"""function(__$spaViewData$__ = {{}}) {{
+                {vars_line}{view_id_line}    let __outputRenderedContent__ = '';
+                try {{
+                    __outputRenderedContent__ = `{chr(10).join(prerender_sections) if prerender_sections else sections_code}`;
+                }} catch(e) {{
+                    __outputRenderedContent__ = this.showError(e.message);
+                    console.warn(e);
+                }}
+                return this.__extends('{extended_view}');
+                }}"""
+        else:
+            return f"""function(__$spaViewData$__ = {{}}) {{
+                {view_id_line}    let __outputRenderedContent__ = '';
+                try {{
+                    __outputRenderedContent__ = `{chr(10).join(prerender_sections) if prerender_sections else sections_code}`;
+                }} catch(e) {{
+                    __outputRenderedContent__ = this.showError(e.message);
+                    console.warn(e);
+                }}
+                return this.__extends('{extended_view}');
+                }}"""
+    else:
+        if has_await or has_fetch:
+            return f"""function(__$spaViewData$__ = {{}}) {{
+                {vars_line}{view_id_line}    let __outputRenderedContent__ = '';
+                try {{
+                    __outputRenderedContent__ = `<div class="{HTML_ATTR_PREFIX}preloader" ref="${{__VIEW_ID__}}" data-view-name="${{__VIEW_PATH__}}">${{{JS_FUNCTION_PREFIX}.text('loading')}}</div>`;
+                }} catch(e) {{
+                    __outputRenderedContent__ = this.showError(e.message);
+                    console.warn(e);
+                }}
+                return __outputRenderedContent__;
+                }}"""
+        else:
+            static_content = sections_code if sections_code else template_content
+            return f"""function(__$spaViewData$__ = {{}}) {{
+                {vars_line}{view_id_line}    let __outputRenderedContent__ = '';
+                try {{
+                    __outputRenderedContent__ = `{static_content}`;
+                }} catch(e) {{
+                    __outputRenderedContent__ = this.showError(e.message);
+                    console.warn(e);
+                }}
+                return __outputRenderedContent__;
+                }}"""
+
+def generate_view_engine(view_name, extended_view, sections_info, has_await, has_fetch, fetch_config, uses_vars, has_sections, has_section_preload, has_prerender, prerender_func, render_func, init_func, css_functions, wrapper_config=None):
+    """Generate complete view engine code"""
+    
+    sections_json = json.dumps(sections_info, ensure_ascii=False, separators=(',', ':'))
+    
+    if extended_view:
+        super_view_config = f"'{extended_view}'"
+        has_super_view = "true"
+    else:
+        super_view_config = "null"
+        has_super_view = "false"
+    
+    # Add wrapper config to view engine object
+    wrapper_config_line = ""
+    if wrapper_config:
+        wrapper_config_line = f",\n        wrapperConfig: {wrapper_config}"
+    
+    return f"""function(data = {{}}) {{
+    onst __VIEW_PATH__ = '{view_name}';
+    const __VIEW_ID__ = {JS_FUNCTION_PREFIX}.generateViewId();
+    const self = new {JS_FUNCTION_PREFIX}.Engine('{view_name}', {{
+        superView: {super_view_config},
+        hasSuperView: {has_super_view},
+        sections: {sections_json}{wrapper_config_line},
+        hasAwaitData: {str(has_await).lower()},
+        hasFetchData: {str(has_fetch).lower()},
+        fetch: {json.dumps(fetch_config, ensure_ascii=False).replace('"`', '`').replace('`"', '`') if fetch_config else 'null'},
+        data: data,
+        viewId: __VIEW_ID__,
+        path: __VIEW_PATH__,
+        usesVars: {str(uses_vars).lower()},
+        hasSections: {str(has_sections).lower()},
+        hasSectionPreload: {str(has_section_preload).lower()},
+        hasPrerender: {str(has_prerender).lower()},
+        prerender: {prerender_func},
+        render: {render_func}{css_functions}
+    }});
+    return self;
+    function onStateChange(state) {{
+        self.data = state;
+    }}
+        }}"""

package/scripts/compiler/compiler.config.json

@@ -0,0 +1,36 @@
+{
+  "paths": {
+    "views_input": "resources/views",
+    "js_input": "resources/js/onejs",
+    "build_output": "resources/js/build",
+    "build_scopes": "resources/js/build/scopes",
+    "public_static": "public/static",
+    "app_output": "public/static/app",
+    "scopes_output": "public/static/app/scopes"
+  },
+  "files": {
+    "view_templates": "view.templates.js",
+    "wrapper": "wraper.js",
+    "main": "main.js"
+  },
+  "patterns": {
+    "blade": "**/*.blade.php",
+    "js": "**/*.js"
+  },
+  "settings": {
+    "default_scope": "web",
+    "auto_create_dirs": true,
+    "verbose": false
+  },
+  "build_directories": [
+    "components",
+    "web",
+    "admin", 
+    "layouts",
+    "partials",
+    "custom",
+    "base",
+    "test",
+    "templates"
+  ]
+}