onelaraveljs 1.0.0 → 1.1.3

package/scripts/compiler/style_directive_handler.py

@@ -0,0 +1,169 @@
+"""
+Style Directive Handler - Xử lý @style directive
+Supports: dynamic inline styles với reactive binding
+Uses __styleBinding() method for reactive style management
+"""
+
+import re
+from php_js_converter import php_to_js_advanced
+
+class StyleDirectiveHandler:
+    def __init__(self, state_variables=None):
+        self.state_variables = state_variables or set()
+    
+    def process_style_directive(self, content):
+        """
+        Process @style directive với format:
+        @style(['color' => $textColor, 'font-size' => $fontSize])
+        @style(['background-color' => $isActive ? '#green' : '#red'])
+        
+        Output format: ${this.__styleBinding([...])}
+        
+        Note: Supports multi-line directives within HTML tag attributes
+        """
+        result = content
+        
+        # Process all @style directives globally (supports multi-line)
+        while True:
+            match = re.search(r'@style\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_style_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 _generate_style_output(self, expression):
+        """
+        Generate reactive style binding output
+        
+        Input: ['color' => $textColor, 'font-size' => $fontSize]
+        Output: ${this.__styleBinding([['color', textColor], ['font-size', fontSize]])}
+        """
+        # Parse PHP array syntax
+        styles = self._parse_style_expression(expression)
+        
+        if not styles:
+            return ''
+        
+        # Extract state variables used
+        state_vars = self._extract_state_variables(styles)
+        
+        # Build JavaScript array of [key, value] pairs
+        js_bindings = []
+        for prop, value in styles:
+            # Convert PHP expression to JS
+            js_value = php_to_js_advanced(value)
+            js_bindings.append(f"['{prop}', {js_value}]")
+        
+        js_array = '[' + ', '.join(js_bindings) + ']'
+        
+        # Generate reactive binding with state tracking
+        if state_vars:
+            watch_keys = list(state_vars)
+            return f"${{this.__styleBinding({watch_keys}, {js_array})}}"
+        else:
+            # No state vars, but still use binding for consistency
+            return f"${{this.__styleBinding([], {js_array})}}"
+    
+    def _parse_style_expression(self, expression):
+        """
+        Parse PHP array expression into list of (property, value) tuples
+        
+        Input: 'color' => $textColor, 'font-size' => $fontSize
+        Output: [('color', '$textColor'), ('font-size', '$fontSize')]
+        """
+        styles = []
+        
+        # Remove outer brackets if present
+        expression = expression.strip()
+        if expression.startswith('[') and expression.endswith(']'):
+            expression = expression[1:-1].strip()
+        
+        # Split by commas (but not inside quotes or parentheses)
+        parts = self._smart_split(expression, ',')
+        
+        for part in parts:
+            part = part.strip()
+            if not part:
+                continue
+            
+            # Split by =>
+            if '=>' in part:
+                key_value = part.split('=>', 1)
+                if len(key_value) == 2:
+                    key = key_value[0].strip().strip('\'"')
+                    value = key_value[1].strip()
+                    styles.append((key, value))
+        
+        return styles
+    
+    def _smart_split(self, text, delimiter):
+        """
+        Split text by delimiter, but ignore delimiters inside quotes or parentheses
+        """
+        parts = []
+        current = []
+        depth = 0
+        in_quote = False
+        quote_char = None
+        
+        for i, char in enumerate(text):
+            if char in ('"', "'") and (i == 0 or text[i-1] != '\\'):
+                if not in_quote:
+                    in_quote = True
+                    quote_char = char
+                elif char == quote_char:
+                    in_quote = False
+                    quote_char = None
+            
+            if not in_quote:
+                if char in '([{':
+                    depth += 1
+                elif char in ')]}':
+                    depth -= 1
+                elif char == delimiter and depth == 0:
+                    parts.append(''.join(current))
+                    current = []
+                    continue
+            
+            current.append(char)
+        
+        if current:
+            parts.append(''.join(current))
+        
+        return parts
+    
+    def _extract_state_variables(self, styles):
+        """
+        Extract state variable names from style values
+        """
+        state_vars = set()
+        
+        for _, value in styles:
+            # Find all PHP variables ($varName)
+            var_matches = re.findall(r'\$([a-zA-Z_][a-zA-Z0-9_]*)', value)
+            for var_name in var_matches:
+                if var_name in self.state_variables:
+                    state_vars.add(var_name)
+        
+        return state_vars

package/scripts/compiler/template_analyzer.py

@@ -0,0 +1,162 @@
+"""
+Analyzer cho template content và sections
+"""
+
+from config import JS_FUNCTION_PREFIX
+import re
+
+class TemplateAnalyzer:
+    def __init__(self):
+        pass
+    
+    def analyze_sections_info(self, sections, vars_declaration, has_await, has_fetch):
+        """Analyze sections and return detailed information"""
+        sections_dict = {}  # Use dict to avoid duplicates, key = section_name
+        
+        if not sections:
+            return []
+        
+        # Extract variable names from vars_declaration
+        var_names = []
+        if vars_declaration:
+            vars_match = re.search(r'let\s*\{\s*([^}]+)\s*\}', vars_declaration)
+            if vars_match:
+                vars_content = vars_match.group(1)
+                for var_part in vars_content.split(','):
+                    var_name = var_part.split('=')[0].strip()
+                    var_names.append(var_name)
+        
+        for section in sections:
+            # Extract section name and content
+            # Support both App.View.section, this.__section, and this.__block
+            section_match = re.search(r'(?:App\.View\.section|this\.__section|this\.__block)\([\'"]([^\'"]+)[\'"]', section)
+            if not section_match:
+                continue
+                
+            section_name = section_match.group(1)
+            
+            # Determine section type
+            # Long sections contain template string (backtick)
+            # Short sections don't contain template string
+            if '`' in section:
+                # Contains template string -> long section
+                section_type = "long"
+            else:
+                # No template string -> short section
+                section_type = "short"
+            
+            # Check if section uses variables from @vars
+            use_vars = False
+            if var_names:
+                for var_name in var_names:
+                    # Check for various patterns that indicate variable usage in compiled JavaScript
+                    patterns = [
+                        f'${{{var_name}}}',  # Template literal usage
+                        f'${{{JS_FUNCTION_PREFIX}.escString({var_name})}}',  # Escaped string
+                        f'${{{JS_FUNCTION_PREFIX}.foreach({var_name}',  # Foreach loop
+                        f'${{{JS_FUNCTION_PREFIX}.foreach({var_name},',  # Foreach loop with comma
+                        f'${{{JS_FUNCTION_PREFIX}.foreach({var_name})',  # Foreach loop with paren
+                        f'{JS_FUNCTION_PREFIX}.foreach({var_name}',  # Foreach loop without ${
+                        f'{JS_FUNCTION_PREFIX}.foreach({var_name},',  # Foreach loop with comma without ${
+                        f'{JS_FUNCTION_PREFIX}.foreach({var_name})',  # Foreach loop with paren without ${
+                        f', {var_name})',  # Function parameter
+                        f'({var_name})',  # Function call
+                        f', {var_name}',  # Array/object property
+                        f' {var_name}',  # Space before variable
+                        f'{var_name}',  # Direct variable usage
+                        f'"{var_name}":',  # Object property
+                        f"'{var_name}':",  # Object property with single quotes
+                        f'{{"{var_name}":',  # Object with variable
+                        f"{{'{var_name}':",  # Object with variable single quotes
+                    ]
+                    
+                    for pattern in patterns:
+                        if pattern in section:
+                            use_vars = True
+                            break
+                    if use_vars:
+                        break
+            
+            # Determine preloader
+            preloader = use_vars and (has_await or has_fetch)
+            
+            # Only add or update if not exists, or if current has useVars=True and existing doesn't
+            if section_name not in sections_dict:
+                sections_dict[section_name] = {
+                    "name": section_name,
+                    "type": section_type,
+                    "useVars": use_vars,
+                    "preloader": preloader
+                }
+            else:
+                # Update if current section has useVars=True and existing doesn't
+                existing = sections_dict[section_name]
+                if use_vars and not existing['useVars']:
+                    sections_dict[section_name] = {
+                        "name": section_name,
+                        "type": section_type,
+                        "useVars": use_vars,
+                        "preloader": preloader
+                    }
+        
+        # Convert dict back to list
+        return list(sections_dict.values())
+    
+    def analyze_conditional_structures(self, template_content, vars_declaration, has_await, has_fetch):
+        """Analyze conditional structures outside sections that use vars and need async data"""
+        conditional_info = {
+            'has_conditional_with_vars': False,
+            'conditional_content': template_content
+        }
+        
+        if not vars_declaration or not (has_await or has_fetch):
+            return conditional_info
+        
+        # Extract variable names from vars_declaration
+        var_names = []
+        vars_match = re.search(r'let\s*\{\s*([^}]+)\s*\}', vars_declaration)
+        if vars_match:
+            vars_content = vars_match.group(1)
+            for var_part in vars_content.split(','):
+                var_name = var_part.split('=')[0].strip()
+                var_names.append(var_name)
+        
+        if not var_names:
+            return conditional_info
+        
+        # Check if template has conditional structures outside sections
+        # Look for @if, @elseif, @else, @endif, @switch, @case, @default, @endswitch
+        conditional_patterns = [
+            r'@if\s*\([^)]+\)',
+            r'@elseif\s*\([^)]+\)',
+            r'@else',
+            r'@endif',
+            r'@switch\s*\([^)]+\)',
+            r'@case\s*\([^)]+\)',
+            r'@default',
+            r'@endswitch'
+        ]
+        
+        has_conditionals = any(re.search(pattern, template_content) for pattern in conditional_patterns)
+        
+        if has_conditionals:
+            # Check if any conditional uses variables from @vars
+            for var_name in var_names:
+                patterns = [
+                    f'\${{{var_name}}}',
+                    f'\${{{JS_FUNCTION_PREFIX}.escString\({var_name}\)}}',
+                    f'\${{{JS_FUNCTION_PREFIX}.foreach\({var_name}',
+                    f', {var_name}\)',
+                    f'\({var_name}\)',
+                    f', {var_name}',
+                    f' {var_name}',
+                ]
+                
+                for pattern in patterns:
+                    if re.search(pattern, template_content):
+                        conditional_info['has_conditional_with_vars'] = True
+                        break
+                if conditional_info['has_conditional_with_vars']:
+                    break
+        
+        return conditional_info