onelaraveljs 1.0.0 → 1.1.1

package/scripts/compiler/register_parser.py

@@ -0,0 +1,480 @@
+"""
+Parser cho directive @register với format mới
+"""
+
+import re
+from config import JS_FUNCTION_PREFIX
+
+class RegisterParser:
+    def __init__(self):
+        self.register_content = ""
+        self.scripts = []
+        self.styles = []
+        self.userDefined = {}
+        self.setup_content = []  # Store setup script content for file top
+    
+    def reset(self):
+        self.register_content = ""
+        self.scripts = []
+        self.styles = []
+        self.userDefined = {}
+        self.setup_content = []  # Reset setup content
+        # Reset merged content to prevent data leakage
+        if hasattr(self, '_merged_content'):
+            delattr(self, '_merged_content')
+
+    def parse_register_content(self, content, view_name=None):
+        self.register_content = content
+        self.scripts = []
+        self.styles = []
+        self.userDefined = {}
+        # Reset merged content to prevent data leakage
+        if hasattr(self, '_merged_content'):
+            delattr(self, '_merged_content')
+        
+        self._parse_scripts(content)
+        self._parse_styles(content)
+        
+        return self.get_all_data()
+    
+    def _parse_scripts(self, content):
+        processed_exports = set()
+        processed_scripts = set()  # Track processed scripts to avoid duplicates
+        
+        # Find all script tags with attributes - parse once
+        all_script_matches = re.finditer(r'<script([^>]*?)>(.*?)</script>', content, re.DOTALL)
+        
+        for match in all_script_matches:
+            attrs_string = match.group(1)
+            script_content = match.group(2).strip()
+            full_match = match.group(0)
+            
+            # Skip if already processed
+            if full_match in processed_scripts:
+                continue
+            processed_scripts.add(full_match)
+            
+            # Check if it's external script (has src)
+            if 'src=' in attrs_string:
+                # External script - handle both regular URLs and Blade syntax
+                src_match = re.search(r'src=(["\'])([^"\']*?(?:\{\{[^}]*\}\}[^"\']*?)*[^"\']*?)\1', attrs_string)
+                if src_match:
+                    src = src_match.group(2)
+                    script_obj = {
+                        'type': 'src',
+                        'src': src
+                    }
+                    
+                    # Parse attributes (exclude src to avoid duplication)
+                    attributes = self._parse_attributes(attrs_string, exclude_attrs=['src'])
+                    if attributes.get('id'):
+                        script_obj['id'] = attributes['id']
+                    if attributes.get('className'):
+                        script_obj['className'] = attributes['className']
+                    if attributes.get('attributes'):
+                        script_obj['attributes'] = attributes['attributes']
+                    
+                    self.scripts.append(script_obj)
+            else:
+                # Inline script
+                if not script_content:
+                    continue
+                
+                # Parse attributes
+                script_obj = {
+                    'type': 'code',
+                    'content': script_content
+                }
+                
+                # Add attributes
+                attributes = self._parse_attributes(attrs_string)
+                if attributes.get('id'):
+                    script_obj['id'] = attributes['id']
+                if attributes.get('className'):
+                    script_obj['className'] = attributes['className']
+                if attributes.get('attributes'):
+                    script_obj['attributes'] = attributes['attributes']
+                
+                # Check if this is a setup script (has setup, view, or component attribute)
+                is_setup_script = self._is_setup_script(attributes)
+                
+                export_match = self._find_export_object(script_content)
+                remaining_content = script_content
+                
+                if export_match:
+                    obj_content = export_match.group(1)
+                    obj_hash = hash(obj_content)
+                    
+                    if obj_hash not in processed_exports:
+                        processed_exports.add(obj_hash)
+                        self._extract_to_user_defined(obj_content)
+                    
+                    # Remove export statement from script content
+                    remaining_content = self._remove_export_from_script(script_content, is_setup_script)
+                
+                # For setup scripts, store remaining content for file top (after removing export)
+                if is_setup_script:
+                    # Store the remaining content (everything except export but keep imports) for file top
+                    remaining_without_export = self._remove_only_export_from_script(script_content)
+                    if remaining_without_export.strip():
+                        self.setup_content.append(remaining_without_export.strip())
+                # For regular scripts, only add if there's remaining content after removing export
+                elif remaining_content.strip():
+                    script_obj['content'] = remaining_content
+                    self.scripts.append(script_obj)
+    
+    def _parse_styles(self, content):
+        # Parse inline styles with attributes
+        style_matches = re.finditer(r'<style([^>]*?)>(.*?)</style>', content, re.DOTALL)
+        
+        for match in style_matches:
+            attrs_string = match.group(1)
+            css_content = match.group(2).strip()
+            
+            if css_content:
+                style_obj = {
+                    'type': 'code',
+                    'content': css_content
+                }
+                
+                # Parse attributes
+                attributes = self._parse_attributes(attrs_string)
+                if attributes.get('id'):
+                    style_obj['id'] = attributes['id']
+                if attributes.get('className'):
+                    style_obj['className'] = attributes['className']
+                if attributes.get('attributes'):
+                    style_obj['attributes'] = attributes['attributes']
+                
+                self.styles.append(style_obj)
+        
+        # Parse external stylesheets with attributes
+        # Use a more flexible pattern that handles Blade syntax better
+        link_pattern = r'<link([^>]*?)rel=["\']stylesheet["\']([^>]*?)>'
+        link_matches = re.finditer(link_pattern, content)
+        
+        for match in link_matches:
+            full_tag = match.group(0)
+            attrs_combined = match.group(1) + match.group(2)
+            
+            # Extract href - handle both regular URLs and Blade syntax
+            href_match = re.search(r'href=(["\'])([^"\']*?(?:\{\{[^}]*\}\}[^"\']*?)*[^"\']*?)\1', full_tag)
+            if href_match:
+                href = href_match.group(2)
+                
+                style_obj = {
+                    'type': 'href',
+                    'href': href
+                }
+                
+                # Parse attributes (exclude href and rel to avoid duplication)
+                attributes = self._parse_attributes(attrs_combined, exclude_attrs=['href', 'rel'])
+                if attributes.get('id'):
+                    style_obj['id'] = attributes['id']
+                if attributes.get('className'):
+                    style_obj['className'] = attributes['className']
+                if attributes.get('attributes'):
+                    style_obj['attributes'] = attributes['attributes']
+                
+                self.styles.append(style_obj)
+    
+    def _parse_attributes(self, attrs_string, exclude_attrs=None):
+        """Parse HTML attributes from string and extract id, class, and other attributes"""
+        if exclude_attrs is None:
+            exclude_attrs = []
+        
+        result = {
+            'id': '',
+            'className': '',
+            'attributes': {}
+        }
+        
+        if not attrs_string or not attrs_string.strip():
+            return result
+        
+        # Parse attributes using regex
+        attr_pattern = r'(\w+(?:-\w+)*)(?:=(["\'])([^"\']*?)\2|(?==|\s|$))'
+        matches = re.findall(attr_pattern, attrs_string)
+        
+        for match in matches:
+            attr_name = match[0].strip()
+            attr_value = match[2] if len(match) > 2 else None
+            
+            # Skip excluded attributes
+            if attr_name in exclude_attrs:
+                continue
+            
+            if attr_name == 'id':
+                result['id'] = attr_value or ''
+            elif attr_name == 'class':
+                result['className'] = attr_value or ''
+            elif attr_name in ['script', 'view', 'component', 'setup', 'defer', 'async']:
+                # Boolean attributes - if present without value, set to true
+                if attr_value is None or attr_value == '':
+                    result['attributes'][attr_name] = True
+                else:
+                    result['attributes'][attr_name] = attr_value
+            else:
+                # Other attributes
+                if attr_value is None or attr_value == '':
+                    # Boolean attribute
+                    result['attributes'][attr_name] = True
+                else:
+                    result['attributes'][attr_name] = attr_value
+        
+        # Clean up empty attributes
+        if not result['attributes']:
+            del result['attributes']
+        
+        return result
+
+    def _remove_export_from_script(self, script_content, is_setup_script=False):
+        """Remove export statement from script content and return remaining content"""
+        # Remove export statement first
+        export_pattern = r'export\s+(?:default\s+)?(\{)'
+        match = re.search(export_pattern, script_content, re.DOTALL)
+        
+        remaining_content = script_content
+        
+        if match:
+            # Find the full export statement including trailing semicolon/newline
+            export_start = match.start()
+            start_pos = match.start(1)
+            brace_count = 1
+            end_pos = start_pos + 1
+            
+            # Find matching closing brace
+            while end_pos < len(script_content) and brace_count > 0:
+                char = script_content[end_pos]
+                if char == '{':
+                    brace_count += 1
+                elif char == '}':
+                    brace_count -= 1
+                end_pos += 1
+            
+            if brace_count == 0:
+                # Include trailing semicolon if present
+                while end_pos < len(script_content) and script_content[end_pos] in [';', ' ', '\t']:
+                    end_pos += 1
+                
+                # Include trailing newlines
+                while end_pos < len(script_content) and script_content[end_pos] in ['\n', '\r']:
+                    end_pos += 1
+                
+                # Remove the export statement
+                remaining_content = script_content[:export_start] + script_content[end_pos:]
+        
+        # For setup scripts, return empty string (all remaining content goes to file top)
+        # For regular scripts, remove import statements only (these will be handled at file level)
+        if is_setup_script:
+            return ""
+        else:
+            # Remove all import statements (these will be handled at file level)
+            import_pattern = r'import\s+.*?(?:from\s+["\'][^"\']*["\']|["\'][^"\']*["\'])\s*;?\s*\n?'
+            remaining_content = re.sub(import_pattern, '', remaining_content, flags=re.MULTILINE)
+        
+        return remaining_content.strip()
+
+    def _remove_only_export_from_script(self, script_content):
+        """Remove only export statement from script content, keep everything else including imports"""
+        # Remove export statement only
+        export_pattern = r'export\s+(?:default\s+)?(\{)'
+        match = re.search(export_pattern, script_content, re.DOTALL)
+        
+        if not match:
+            return script_content
+        
+        # Find the full export statement including trailing semicolon/newline
+        export_start = match.start()
+        start_pos = match.start(1)
+        brace_count = 1
+        end_pos = start_pos + 1
+        
+        # Find matching closing brace
+        while end_pos < len(script_content) and brace_count > 0:
+            char = script_content[end_pos]
+            if char == '{':
+                brace_count += 1
+            elif char == '}':
+                brace_count -= 1
+            end_pos += 1
+        
+        if brace_count == 0:
+            # Include trailing semicolon if present
+            while end_pos < len(script_content) and script_content[end_pos] in [';', ' ', '\t']:
+                end_pos += 1
+            
+            # Include trailing newlines
+            while end_pos < len(script_content) and script_content[end_pos] in ['\n', '\r']:
+                end_pos += 1
+            
+            # Remove the export statement
+            remaining_content = script_content[:export_start] + script_content[end_pos:]
+            return remaining_content.strip()
+        
+        return script_content
+
+    def _find_export_object(self, script_content):
+        """Find and extract export object with proper brace matching"""
+        # Look for export or export default
+        export_pattern = r'export\s+(?:default\s+)?(\{)'
+        match = re.search(export_pattern, script_content, re.DOTALL)
+        
+        if not match:
+            return None
+        
+        start_pos = match.start(1)
+        brace_count = 1
+        end_pos = start_pos + 1
+        
+        # Find matching closing brace
+        while end_pos < len(script_content) and brace_count > 0:
+            char = script_content[end_pos]
+            if char == '{':
+                brace_count += 1
+            elif char == '}':
+                brace_count -= 1
+            end_pos += 1
+        
+        if brace_count == 0:
+            obj_content = script_content[start_pos:end_pos]
+            
+            class MockMatch:
+                def group(self, n):
+                    return obj_content
+            
+            return MockMatch()
+        
+        return None
+    
+    def _is_setup_script(self, attributes):
+        """Check if script has setup, view, or component attributes"""
+        if not attributes or 'attributes' not in attributes:
+            return False
+        
+        script_attributes = attributes['attributes']
+        setup_attrs = ['setup', 'view', 'component']
+        
+        # Check if any setup attribute exists
+        return any(attr in script_attributes for attr in setup_attrs)
+    
+    def _extract_to_user_defined(self, obj_content):
+        """Just store the raw object content - bê nguyên vào userDefined"""
+        obj_content = obj_content.strip()
+        
+        # Chỉ cần store raw object content - main_compiler sẽ sử dụng trực tiếp
+        # Vì có thể có nhiều exports, ta merge vào một object
+        if obj_content.startswith('{') and obj_content.endswith('}'):
+            # Remove outer braces và merge content
+            inner_content = obj_content[1:-1].strip()
+            if inner_content:
+                # Nếu đã có userDefined content, merge với dấu phẩy
+                if hasattr(self, '_merged_content'):
+                    self._merged_content += ",\n    " + inner_content
+                else:
+                    self._merged_content = inner_content
+    
+    def get_scripts(self):
+        return self.scripts
+    
+    def get_styles(self):
+        return self.styles
+    
+    def get_user_defined(self):
+        return self.userDefined
+    
+    def get_all_data(self):
+        # Get merged lifecycle object
+        lifecycle_obj = self.get_lifecycle_obj()
+        
+        return {
+            'scripts': self.scripts,
+            'styles': self.styles,
+            'userDefined': lifecycle_obj,  # Raw object string
+            # Backward compatibility
+            'lifecycle': lifecycle_obj,  # main_compiler expects 'lifecycle'
+            'setup': self.get_setup_script(),
+            'setupContent': self.get_setup_content(),  # Content for file top
+            'sections': {},
+            'css': {
+                'inline': self.get_inline_css(),
+                'external': self.get_external_css()
+            },
+            'resources': self.get_resources()
+        }
+    
+    # Backward compatibility methods
+    def get_lifecycle_obj(self):
+        # Return merged object content như format cũ
+        if hasattr(self, '_merged_content') and self._merged_content:
+            return "{\n    " + self._merged_content + "\n}"
+        return self.userDefined if isinstance(self.userDefined, str) else "{}"
+    
+    def get_setup_script(self):
+        code_scripts = [s['content'] for s in self.scripts if s['type'] == 'code']
+        return '\n\n'.join(code_scripts) if code_scripts else ""
+    
+    def get_setup_content(self):
+        """Get setup script content that should go to file top"""
+        return '\n\n'.join(self.setup_content) if self.setup_content else ""
+    
+    def get_section_scripts(self):
+        return {}
+    
+    def get_all_scripts(self, view_name=None):
+        return {
+            'lifecycle': self.userDefined,
+            'setup': self.get_setup_script(),
+            'scripts': self.scripts
+        }
+    
+    def get_inline_css(self):
+        inline_css = [s['content'] for s in self.styles if s['type'] == 'code']
+        return '\n'.join(inline_css) if inline_css else ""
+    
+    def get_external_css(self):
+        return [s['href'] for s in self.styles if s['type'] == 'href']
+    
+    def get_resources(self):
+        resources = []
+        
+        for script in self.scripts:
+            if script['type'] == 'src':
+                attrs = {'src': script['src']}
+                
+                # Add other attributes
+                if 'attributes' in script:
+                    attrs.update(script['attributes'])
+                if 'id' in script and script['id']:
+                    attrs['id'] = script['id']
+                if 'className' in script and script['className']:
+                    attrs['class'] = script['className']
+                
+                resources.append({
+                    'tag': 'script',
+                    'uuid': f"script-{len(resources)}",
+                    'attrs': attrs
+                })
+        
+        for style in self.styles:
+            if style['type'] == 'href':
+                attrs = {
+                    'rel': 'stylesheet',
+                    'href': style['href']
+                }
+                
+                # Add other attributes
+                if 'attributes' in style:
+                    attrs.update(style['attributes'])
+                if 'id' in style and style['id']:
+                    attrs['id'] = style['id']
+                if 'className' in style and style['className']:
+                    attrs['class'] = style['className']
+                
+                resources.append({
+                    'tag': 'link',
+                    'uuid': f"link-{len(resources)}",
+                    'attrs': attrs
+                })
+        
+        return resources

package/scripts/compiler/section_handlers.py

@@ -0,0 +1,122 @@
+"""
+Handlers cho các section directives (@section, @endsection, @yield, etc.)
+"""
+
+from config import JS_FUNCTION_PREFIX
+from php_converter import php_to_js
+import re
+
+class SectionHandlers:
+    def __init__(self):
+        pass
+    
+    def process_section_directive(self, line, stack, output, sections):
+        """Process @section directive"""
+        # Two parameter version
+        match_two = re.match(r'@section\s*\(\s*[\'"]([^\'"]*)[\'"]\s*,\s*(.*?)\s*\)', line, re.DOTALL)
+        if match_two and ',' in line:
+            section_name = match_two.group(1)
+            section_value_raw = match_two.group(2).strip()
+            
+            # Handle string literals directly without php_to_js to avoid corruption
+            if ((section_value_raw.startswith("'") and section_value_raw.endswith("'")) or 
+                (section_value_raw.startswith('"') and section_value_raw.endswith('"'))):
+                # Direct string literal - fix escaping
+                section_value = self._ensure_proper_escaping(section_value_raw)
+            else:
+                # Other expressions - use php_to_js
+                section_value = php_to_js(section_value_raw) if section_value_raw else "''"
+                section_value = self._ensure_proper_escaping(section_value)
+            
+            result = '${' + JS_FUNCTION_PREFIX + '.section(\'' + section_name + '\', ' + section_value + ', \'string\')}'
+            output.append(result)
+            sections.append(result)
+            return True
+        
+        # Single parameter version
+        match_one = re.match(r'@section\s*\(\s*[\'"]([^\'"]*)[\'"]|([^)]*)\s*\)', line)
+        if match_one:
+            section_name = match_one.group(1) or php_to_js(match_one.group(2))
+            stack.append(('section', section_name, len(output)))
+            return True
+        
+        return False
+    
+    def process_endsection_directive(self, stack, output, sections):
+        """Process @endsection directive"""
+        if stack and stack[-1][0] == 'section':
+            _, section_name, start_idx = stack.pop()
+            # Filter out boolean values and join strings
+            section_content = '\n'.join([str(item) for item in output[start_idx:] if isinstance(item, str)])
+            output[:] = output[:start_idx]  # Modify output in place
+            
+            # Determine section type based on content
+            section_type = 'html' if self._contains_html_tags(section_content) else 'string'
+            
+            section_line = '${' + JS_FUNCTION_PREFIX + '.section(\'' + section_name + '\', `' + section_content + '`, \'' + section_type + '\')}'
+            output.append(section_line)
+            sections.append(section_line)
+        return True
+    
+    def process_block_directive(self, line, stack, output, sections):
+        """Process @block directive - similar to @section"""
+        # Two parameter version: @block('name', attributes)
+        match_two = re.match(r'@block\s*\(\s*[\'"]([^\'"]*)[\'"]\s*,\s*(.*?)\s*\)', line)
+        if match_two and ',' in line:
+            block_name = match_two.group(1)
+            block_attributes = match_two.group(2)
+            block_attributes_js = php_to_js(block_attributes) if block_attributes else "{}"
+            result = '${this.__block(\'' + block_name + '\', ' + block_attributes_js + ', `'
+            stack.append(('block', block_name, len(output), block_attributes_js))
+            return True
+        
+        # Single parameter version: @block('name')
+        match_one = re.match(r'@block\s*\(\s*[\'"]([^\'"]*)[\'"]|([^)]*)\s*\)', line)
+        if match_one:
+            block_name = match_one.group(1) or php_to_js(match_one.group(2))
+            result = '${this.__block(\'' + block_name + '\', {}, `'
+            stack.append(('block', block_name, len(output), '{}'))
+            return True
+        
+        return False
+    
+    def process_endblock_directive(self, stack, output, sections):
+        """Process @endblock/@endBlock directive - similar to @endsection"""
+        if stack and stack[-1][0] == 'block':
+            _, block_name, start_idx, block_attributes = stack.pop()
+            # Filter out boolean values and join strings
+            block_content = '\n'.join([str(item) for item in output[start_idx:] if isinstance(item, str)])
+            output[:] = output[:start_idx]  # Modify output in place
+            
+            # Complete the block call
+            block_line = '${this.__block(\'' + block_name + '\', ' + block_attributes + ', `' + block_content + '`)}'
+            output.append(block_line)
+            sections.append(block_line)
+        return True
+
+    def _contains_html_tags(self, content):
+        """Check if content contains HTML tags"""
+        # Simple check for HTML tags
+        html_pattern = r'<[a-zA-Z][^>]*>'
+        return bool(re.search(html_pattern, content))
+
+    def _ensure_proper_escaping(self, section_value):
+        """Ensure section value is properly escaped for JavaScript string literals"""
+        # If it's already a string literal (starts and ends with quotes), fix escaping
+        if ((section_value.startswith("'") and section_value.endswith("'")) or 
+            (section_value.startswith('"') and section_value.endswith('"'))):
+            # Extract content and re-escape properly
+            quote_char = section_value[0]
+            content = section_value[1:-1]  # Remove quotes
+            
+            # Escape single quotes in content
+            if quote_char == "'":
+                content = content.replace("\\'", "'")  # Unescape first
+                content = content.replace("'", "\\'")  # Re-escape properly
+            else:
+                content = content.replace('\\"', '"')  # Unescape first  
+                content = content.replace('"', '\\"')  # Re-escape properly
+            
+            return quote_char + content + quote_char
+        
+        return section_value

package/scripts/compiler/show_directive_handler.py

@@ -0,0 +1,85 @@
+"""
+Show Directive Handler - Xử lý @show directive
+Similar to Vue's v-show - toggles element visibility with display property
+"""
+
+import re
+from php_js_converter import php_to_js_advanced
+
+class ShowDirectiveHandler:
+    def __init__(self, state_variables=None):
+        self.state_variables = state_variables or set()
+    
+    def process_show_directive(self, content):
+        """
+        Process @show directive
+        @show($isVisible) -> style="${this.__showBinding(['isVisible'], isVisible)}"
+        
+        Similar to v-show in Vue - element always exists in DOM, just toggles display
+        
+        Note: Supports multi-line directives within HTML tag attributes
+        """
+        result = content
+        
+        # Process all @show directives globally (supports multi-line)
+        while True:
+            match = re.search(r'@show\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_show_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_show_output(self, expression):
+        """
+        Generate reactive show binding output
+        
+        Input: $isVisible
+        Output: style="${this.__showBinding(['isVisible'], isVisible)}"
+        """
+        # Convert PHP expression to JS
+        js_expression = php_to_js_advanced(expression)
+        
+        # Extract state variables
+        state_vars = self._extract_state_variables(expression)
+        
+        if state_vars:
+            watch_keys = list(state_vars)
+            return f'style="${{this.__showBinding({watch_keys}, {js_expression})}}"'
+        else:
+            # No state vars, but still use binding for consistency
+            return f'style="${{this.__showBinding([], {js_expression})}}"'
+    
+    def _extract_state_variables(self, expression):
+        """
+        Extract state variable names from expression
+        """
+        state_vars = set()
+        
+        # Find all PHP variables ($varName)
+        var_matches = re.findall(r'\$([a-zA-Z_][a-zA-Z0-9_]*)', expression)
+        for var_name in var_matches:
+            if var_name in self.state_variables:
+                state_vars.add(var_name)
+        
+        return state_vars