onelaraveljs 1.21.21 → 1.21.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onelaraveljs",
-  "version": "1.21.21",
+  "version": "1.21.23",
   "description": "OneLaravel JS Framework Core & Compiler",
   "main": "index.js",
   "exports": {

package/scripts/compiler/conditional_handlers.py

@@ -60,29 +60,29 @@ class ConditionalHandlers:
                         parent_is_loop = True
                         parent_concat_var = f"__{parent_type}OutputContent__"
                 
-                # If inside a loop and has state vars, use concat += with __reactive
+                # If inside a loop and has state vars, use concat += with __watch
                 if parent_is_loop and watch_keys:
                     if self.processor:
                         self.processor.watch_counter += 1
                         watch_id = f"`${{__VIEW_ID__}}-watch-{self.processor.watch_counter}-${{__loop.index}}`"
                     else:
                         watch_id = "`${__VIEW_ID__}-watch-0-${__loop.index}`"
-                    result = f"{parent_concat_var} += this.__reactive({watch_id}, {watch_keys}, (__rc__) => {{ if({condition}){{ return `"
+                    result = f"{parent_concat_var} += this.__watch({watch_id}, {watch_keys}, () => {{ if({condition}){{ return `"
                 # If inside a loop but no state vars, use concat += with IIFE
                 elif parent_is_loop:
                     result = f"{parent_concat_var} += (() => {{ if({condition}){{ return `"
-                # Only wrap with __reactive for block-level directives (not attributes, not in loops)
+                # Only wrap with __watch for block-level directives (not attributes, not in loops)
                 elif is_attribute_context or not watch_keys:
                     # Attribute directive or no state vars - no watch wrapping
                     result = f"${{this.__execute(() => {{ if({condition}){{ return `"
                 else:
-                    # Block directive with state vars - wrap with __reactive
+                    # Block directive with state vars - wrap with __watch
                     if self.processor:
                         self.processor.watch_counter += 1
                         watch_id = f"`${{__VIEW_ID__}}-watch-{self.processor.watch_counter}`"
                     else:
                         watch_id = "`${__VIEW_ID__}-watch-0`"
-                    result = f"${{this.__reactive({watch_id}, {watch_keys}, (__rc__) => {{ if({condition}){{ return `"
+                    result = f"${{this.__watch({watch_id}, {watch_keys}, () => {{ if({condition}){{ return `"
                 
                 output.append(result)
                 stack.append(('if', len(output), watch_keys, is_attribute_context, parent_is_loop))
@@ -136,18 +136,15 @@ class ConditionalHandlers:
             output.append("return '';")
             
             if parent_is_loop and watch_keys:
-                # Inside loop with state vars - close reactive without template wrapper
-                # Pattern: }, {type: 'watch'}); where } closes arrow func, }, {type: 'watch'}) closes reactive call, ; ends statement
-                output.append("}, {type: 'watch'});")
+                # Inside loop with state vars - close watch without template wrapper
+                # Pattern: })); where } closes arrow func, )) closes watch call, ; ends statement
+                output.append('});')
             elif parent_is_loop:
                 # Inside loop without state vars - close IIFE with immediate execution
                 output.append('})')
             else:
-                # Normal block - close IIFE or reactive
-                if watch_keys:
-                    output.append("}, {type: 'watch'}})")
-                else:
-                    output.append('})}')
+                # Normal block - close IIFE or watch
+                output.append('})}')
         return True
     
     def process_switch_directive(self, line, stack, output, is_attribute_context=False):
@@ -193,7 +190,7 @@ class ConditionalHandlers:
                             watch_id = f"`${{__VIEW_ID__}}-watch-{self.processor.watch_counter}`"
                         else:
                             watch_id = "`${__VIEW_ID__}-watch-0`"
-                        result = f"{concat_var} += this.__reactive({watch_id}, {watch_keys}, (__rc__) => {{\n{switch_logic}"
+                        result = f"{concat_var} += this.__watch({watch_id}, {watch_keys}, () => {{\n{switch_logic}"
                 else:
                     # Parent uses template literal, so output template expression
                     if is_attribute_context or not watch_keys:
@@ -204,7 +201,7 @@ class ConditionalHandlers:
                             watch_id = f"`${{__VIEW_ID__}}-watch-{self.processor.watch_counter}`"
                         else:
                             watch_id = "`${__VIEW_ID__}-watch-0`"
-                        result = f"${{this.__reactive({watch_id}, {watch_keys}, (__rc__) => {{\n{switch_logic}"
+                        result = f"${{this.__watch({watch_id}, {watch_keys}, () => {{\n{switch_logic}"
                 
                 output.append(result)
                 stack.append(('switch', len(output), watch_keys, is_attribute_context, parent_is_concat))
@@ -242,20 +239,13 @@ class ConditionalHandlers:
         if stack and stack[-1][0] == 'switch':
             switch_info = stack.pop()
             parent_is_concat = switch_info[4] if len(switch_info) > 4 else False
-            has_watch = switch_info[2] if len(switch_info) > 2 else []
             
             if parent_is_concat:
-                # Parent uses concatenation
-                if has_watch:
-                    result = "`;\n}\nreturn __switchOutputContent__;\n}, {type: 'watch'})"
-                else:
-                    result = "`;\n}\nreturn __switchOutputContent__;\n})"
+                # Parent uses concatenation, close with })
+                result = "`;\n}\nreturn __switchOutputContent__;\n})"
             else:
-                # Parent uses template literal
-                if has_watch:
-                    result = "`;\n}\nreturn __switchOutputContent__;\n}, {type: 'watch'}})"
-                else:
-                    result = "`;\n}\nreturn __switchOutputContent__;\n})}"
+                # Parent uses template literal, output template expression
+                result = "`;\n}\nreturn __switchOutputContent__;\n})}"
             
             output.append(result)
             return True

package/scripts/compiler/declaration_tracker.py

@@ -111,22 +111,6 @@ class DeclarationTracker:
         """Parse @vars content and extract variables"""
         variables = []
         
-        # Handle array syntax: ['var1', 'var2'] or ["var1", "var2"]
-        if content.startswith('[') and content.endswith(']'):
-            # Extract array items
-            inner = content[1:-1].strip()
-            # Parse quoted strings
-            import re
-            # Find all quoted strings (single or double quotes)
-            matches = re.findall(r'''['"](.*?)['"]''', inner)
-            for var_name in matches:
-                variables.append({
-                    'name': var_name.strip(),
-                    'value': None,
-                    'hasDefault': False
-                })
-            return variables
-        
         # Handle object destructuring {var1, var2}
         if content.startswith('{') and content.endswith('}'):
             inner = content[1:-1]

package/scripts/compiler/directive_processors.py

@@ -298,12 +298,10 @@ class DirectiveProcessor:
 
         # Build the output
         if vars_set:
-            # Has variables - use __reactive with subscription
+            # Has variables - use __output with subscription
             subscribe = ','.join([f"'{v}'" for v in vars_set])
             subscribe_js = f'[{subscribe}]'
-            # Generate reactive ID
-            reactive_id = f'`${{__VIEW_ID__}}-json-{len(vars_set)}`'
-            return '${' + f"this.__reactive({reactive_id}, {subscribe_js}, (__rc__) => JSON.stringify({js_expr}), {{type: 'output', escapeHTML: false}})" + '}'
+            return '${' + f"this.__output({subscribe_js}, () => JSON.stringify({js_expr}))" + '}'
         else:
             # No variables - direct JSON.stringify
             return '${' + f"JSON.stringify({js_expr})" + '}'
@@ -453,11 +451,9 @@ class DirectiveProcessor:
         else:
             subscribe_js = '[]'
 
-        # Generate reactive ID
-        reactive_id = f'`${{__VIEW_ID__}}-out-{len(vars_set)}`'
-        # Return the output wrapper using this.__reactive
-        # Produce string like: ${this.__reactive(id, ['a','b'], (__rc__) => (expr), {type: 'output', escapeHTML: false})}
-        return '${' + "this.__reactive(" + reactive_id + ", " + subscribe_js + ", (__rc__) => (" + js_expr + "), {type: 'output', escapeHTML: false})" + '}'
+        # Return the output wrapper using this.__output
+        # Produce string like: ${this.__output(['a','b'], () => (expr))}
+        return '${' + "this.__output(" + subscribe_js + ", () => (" + js_expr + "))}"
     
     def process_register_directive(self, line, stack, output):
         """Process @register directive - chỉ để đánh dấu, không tạo output"""

package/scripts/compiler/loop_handlers.py

@@ -61,18 +61,18 @@ class LoopHandlers:
                     # Use this.__foreach for instance method
                     foreach_call = f"this.__foreach({array_expr}, {callback}"
                     
-                    # Only wrap with __reactive for block-level directives (not attributes)
+                    # Only wrap with __watch for block-level directives (not attributes)
                     if is_attribute_context:
-                        # Attribute directive - no reactive wrapping
+                        # Attribute directive - no watch wrapping
                         result = f"${{{foreach_call}"
                     else:
-                        # Block directive - wrap with __reactive
+                        # Block directive - wrap with __watch
                         if self.processor:
                             self.processor.watch_counter += 1
                             watch_id = f"`${{__VIEW_ID__}}-watch-{self.processor.watch_counter}`"
                         else:
                             watch_id = "`${__VIEW_ID__}-watch-0`"
-                        result = f"${{this.__reactive({watch_id}, {watch_keys}, (__rc__) => {foreach_call}"
+                        result = f"${{this.__watch({watch_id}, {watch_keys}, () => {foreach_call}"
                     
                     output.append(result)
                     stack.append(('foreach', len(output), is_attribute_context))
@@ -85,11 +85,11 @@ class LoopHandlers:
             is_attribute = stack[-1][2] if len(stack[-1]) > 2 else False
             stack.pop()
             if is_attribute:
-                # Attribute directive - no reactive wrapper
+                # Attribute directive - no watch wrapper
                 output.append('`)}')
             else:
-                # Block directive - close reactive wrapper
-                output.append("`), {type: 'watch'}})")
+                # Block directive - close watch wrapper
+                output.append('`))}') 
         return True
     
     def process_for_directive(self, line, stack, output, is_attribute_context=False):
@@ -124,7 +124,7 @@ class LoopHandlers:
                     # Wrap in __for() with __loop parameter
                     for_call = f"this.__for('increment', {start_value}, {end_value}, (__loop) => {{\n{for_logic}"
                     
-                    # Only wrap with __reactive for block-level directives (not attributes)
+                    # Only wrap with __watch for block-level directives (not attributes)
                     has_watch = not is_attribute_context and watch_keys
                     if is_attribute_context or not watch_keys:
                         result = f"${{{for_call}"
@@ -134,7 +134,7 @@ class LoopHandlers:
                             watch_id = f"`${{__VIEW_ID__}}-watch-{self.processor.watch_counter}`"
                         else:
                             watch_id = "`${__VIEW_ID__}-watch-0`"
-                        result = f"${{this.__reactive({watch_id}, {watch_keys}, (__rc__) => {{ return {for_call}"
+                        result = f"${{this.__watch({watch_id}, {watch_keys}, () => {{ return {for_call}"
                     
                     output.append(result)
                     stack.append(('for', len(output), is_attribute_context, has_watch))
@@ -152,14 +152,16 @@ class LoopHandlers:
                 # Attribute directive - close __for
                 result = "\n}\nreturn __forOutputContent__;\n})\n}"
             elif has_watch:
-                # Block directive with reactive - close __for, reactive callback
+                # Block directive with watch - close __for, watch callback, and watch wrapper
                 # Pattern:
                 # } closes for loop body
                 # return __forOutputContent__;
                 # }) closes for arrow body and params
-                # }, {type: 'watch'}) closes __reactive call
+                # ); closes __for call and ends return statement
+                # } closes watch callback arrow body
+                # ) closes __watch call
                 # } closes ${}
-                result = "\n}\nreturn __forOutputContent__;\n})\n}, {type: 'watch'})}"
+                result = "\n}\nreturn __forOutputContent__;\n})\n})}}"
             else:
                 # Block directive without watch - close __for only
                 result = "\n}\nreturn __forOutputContent__;\n})\n}"
@@ -189,7 +191,7 @@ class LoopHandlers:
                 # Generate while loop
                 while_logic = f"let __whileOutputContent__ = ``;\nwhile({condition}) {{"
                 
-                # Only wrap with __reactive for block-level directives (not attributes)
+                # Only wrap with __watch for block-level directives (not attributes)
                 if is_attribute_context or not watch_keys:
                     result = f"${{this.__execute(() => {{\n{while_logic}"
                 else:
@@ -198,7 +200,7 @@ class LoopHandlers:
                         watch_id = f"`${{__VIEW_ID__}}-watch-{self.processor.watch_counter}`"
                     else:
                         watch_id = "`${__VIEW_ID__}-watch-0`"
-                    result = f"${{this.__reactive({watch_id}, {watch_keys}, (__rc__) => {{\n{while_logic}"
+                    result = f"${{this.__watch({watch_id}, {watch_keys}, () => {{\n{while_logic}"
                 
                 output.append(result)
                 stack.append(('while', len(output), is_attribute_context))
@@ -215,8 +217,8 @@ class LoopHandlers:
                 # Attribute directive - close IIFE only
                 result = "\n}\nreturn __whileOutputContent__;\n})}"
             else:
-                # Block directive - close reactive wrapper
-                result = "\n}\nreturn __whileOutputContent__;\n}, {type: 'watch'})}"
+                # Block directive - close watch wrapper
+                result = "\n}\nreturn __whileOutputContent__;\n})}"
             
             output.append(result)
         return True

package/scripts/compiler/main_compiler.py

@@ -141,17 +141,13 @@ class BladeCompiler:
         # Extract usestate_variables for event processor
         usestate_variables = self._extract_usestate_variables(usestate_declarations, all_declarations)
         
-        # Extract ALL reactive variables (data + useState + let + const)
-        # In OneJS runtime, all these variables are reactive when used in templates
-        reactive_variables = self._extract_reactive_variables(all_declarations, variable_list)
-        
-        # Update template_processor with reactive_variables (don't reinitialize to preserve watch_counter)
-        self.template_processor.state_variables = reactive_variables
-        self.template_processor.conditional_handlers.state_variables = reactive_variables
-        self.template_processor.loop_handlers.state_variables = reactive_variables
-        self.template_processor.event_processor.state_variables = reactive_variables
-        self.template_processor.echo_processor.state_variables = reactive_variables
-        self.template_processor.class_binding_handler.state_variables = reactive_variables
+        # Update template_processor with usestate_variables (don't reinitialize to preserve watch_counter)
+        self.template_processor.state_variables = usestate_variables
+        self.template_processor.conditional_handlers.state_variables = usestate_variables
+        self.template_processor.loop_handlers.state_variables = usestate_variables
+        self.template_processor.event_processor.state_variables = usestate_variables
+        self.template_processor.echo_processor.state_variables = usestate_variables
+        self.template_processor.class_binding_handler.state_variables = usestate_variables
         
         # Parse block directives
         blade_code = self.parsers.parse_block_directives(blade_code)
@@ -539,9 +535,9 @@ class BladeCompiler:
         # Process binding directives (@val and @bind)
         template_content = self.binding_directive_service.process_all_binding_directives(template_content)
         
-        # Update style and show handlers with reactive variables
-        self.style_directive_handler.state_variables = reactive_variables
-        self.show_directive_handler.state_variables = reactive_variables
+        # Update style and show handlers with state variables
+        self.style_directive_handler.state_variables = usestate_variables
+        self.show_directive_handler.state_variables = usestate_variables
         
         # Process @style directive
         template_content = self.style_directive_handler.process_style_directive(template_content)
@@ -1176,54 +1172,6 @@ class BladeCompiler:
         
         return usestate_variables
     
-    def _extract_reactive_variables(self, all_declarations, variable_list):
-        """
-        Extract ALL reactive variable names (data variables + useState + let + const)
-        In OneJS, all these are reactive in templates:
-        - Data variables from @vars (passed as props/data)
-        - useState variables
-        - let/const variables
-        
-        Returns a set of variable names that should trigger reactive updates
-        """
-        reactive_variables = set()
-        
-        # 1. Add data variables from @vars (variable_list)
-        if variable_list:
-            reactive_variables.update(variable_list)
-        
-        # 2. Add useState variables (state + setters)
-        for decl in all_declarations:
-            if decl.get('type') == 'useState':
-                variables = decl.get('variables', [])
-                for var in variables:
-                    if var.get('isUseState'):
-                        names = var.get('names', [])
-                        if names and len(names) > 0:
-                            # First name is the state variable
-                            state_var = names[0]
-                            if state_var:
-                                reactive_variables.add(state_var)
-                            # Second name is the setter
-                            if len(names) > 1:
-                                setter_var = names[1]
-                                if setter_var:
-                                    reactive_variables.add(setter_var)
-        
-        # 3. Add let/const variables
-        for decl in all_declarations:
-            if decl.get('type') in ['let', 'const']:
-                variables = decl.get('variables', [])
-                for var in variables:
-                    names = var.get('names', [])
-                    if names and len(names) > 0:
-                        # For simple declaration, first name is the variable
-                        var_name = names[0]
-                        if var_name:
-                            reactive_variables.add(var_name)
-        
-        return reactive_variables
-    
     def _detect_state_keys(self, blade_code, let_declarations, const_declarations, usestate_declarations):
         """Detect state keys from directives that use useState or destructuring"""
         state_keys = set()

package/scripts/compiler/template_processor.py

@@ -1031,11 +1031,11 @@ class TemplateProcessor:
             
             include_call = APP_VIEW_NAMESPACE + ".renderView(this.__include('" + view_name + "', " + variables_js + "))"
             
-            # If state variables are used, wrap with __reactive
+            # If state variables are used, wrap with __watch
             # Use placeholder for watch ID that will be replaced later with actual counter
             if state_vars_used:
                 watch_keys = list(state_vars_used)
-                return "${this.__reactive('__INCLUDE_WATCH_PLACEHOLDER__', " + str(watch_keys) + ", (__rc__) => " + include_call + ", {type: 'watch'})}"
+                return "${this.__watch('__INCLUDE_WATCH_PLACEHOLDER__', " + str(watch_keys) + ", () => " + include_call + ")}"
             
             return "${" + include_call + "}"
         
@@ -1072,11 +1072,11 @@ class TemplateProcessor:
             
             include_call = APP_VIEW_NAMESPACE + ".renderView(this.__include(" + view_expr_js + ", " + variables_js + "))"
             
-            # If state variables are used, wrap with __reactive
+            # If state variables are used, wrap with __watch
             # Use placeholder for watch ID that will be replaced later with actual counter
             if state_vars_used:
                 watch_keys = list(state_vars_used)
-                return "${this.__reactive('__INCLUDE_WATCH_PLACEHOLDER__', " + str(watch_keys) + ", (__rc__) => " + include_call + ", {type: 'watch'})}"
+                return "${this.__watch('__INCLUDE_WATCH_PLACEHOLDER__', " + str(watch_keys) + ", () => " + include_call + ")}"
             
             return "${" + include_call + "}"
         

package/src/core/ViewManager.js

@@ -398,40 +398,40 @@ export class ViewManager {
             /**
              * @type {ViewEngine}
              */
-            const cachedPageView = this.store.get(viewStoreKey);
-            if (cachedPageView && cachedPageView instanceof ViewEngine) {
-                // Sử dụng lại cached page view
-                let html = cachedPageView.__._templateManager.renderedHtml || '';
-                this.PAGE_VIEW = cachedPageView;
-                let ultraView = cachedPageView;
-                /**
-                 * @type {ViewEngine}
-                 */
-                let superView = null;
-
-                if (cachedPageView.superView && cachedPageView.superView instanceof ViewEngine) {
-                    superView = cachedPageView.superView;
-                    ultraView = superView;
-                    superView.__.setOriginalView(cachedPageView);
-                    this.CURRENT_SUPER_VIEW_MOUNTED = true;
-                    this.CURRENT_SUPER_VIEW = cachedPageView.superView;
-                    this.CURRENT_SUPER_VIEW_PATH = cachedPageView.superView.path;
-                    cachedPageView.__._templateManager.pushCachedSections();
-                    html = lastSuperViewPath === this.CURRENT_SUPER_VIEW_PATH ? superView.__._templateManager.renderedHtml : this.renderView(superView);
-                }
-                logger.log(`🔍 App.View.loadView: Using cached view for '${name}' with URL path '${urlPath}'`);
-                // trả về kết quả
-                return {
-                    html: html,
-                    isSuperView: superView ? true : false,
-                    needInsert: superView && (lastSuperViewPath === superView.path) ? false : true,
-                    superView: superView,
-                    ultraView: ultraView,
-                    error: null,
-                    isCached: true
-                };
-
-            }
+            // const cachedPageView = this.store.get(viewStoreKey);
+            // if (cachedPageView && cachedPageView instanceof ViewEngine) {
+            //     // Sử dụng lại cached page view
+            //     let html = cachedPageView.__._templateManager.renderedHtml || '';
+            //     this.PAGE_VIEW = cachedPageView;
+            //     let ultraView = cachedPageView;
+            //     /**
+            //      * @type {ViewEngine}
+            //      */
+            //     let superView = null;
+
+            //     if (cachedPageView.superView && cachedPageView.superView instanceof ViewEngine) {
+            //         superView = cachedPageView.superView;
+            //         ultraView = superView;
+            //         superView.__.setOriginalView(cachedPageView);
+            //         this.CURRENT_SUPER_VIEW_MOUNTED = true;
+            //         this.CURRENT_SUPER_VIEW = cachedPageView.superView;
+            //         this.CURRENT_SUPER_VIEW_PATH = cachedPageView.superView.path;
+            //         cachedPageView.__._templateManager.pushCachedSections();
+            //         html = lastSuperViewPath === this.CURRENT_SUPER_VIEW_PATH ? superView.__._templateManager.renderedHtml : this.renderView(superView);
+            //     }
+            //     logger.log(`🔍 App.View.loadView: Using cached view for '${name}' with URL path '${urlPath}'`);
+            //     // trả về kết quả
+            //     return {
+            //         html: html,
+            //         isSuperView: superView ? true : false,
+            //         needInsert: superView && (lastSuperViewPath === superView.path) ? false : true,
+            //         superView: superView,
+            //         ultraView: ultraView,
+            //         error: null,
+            //         isCached: true
+            //     };
+
+            // }
 
             let hasCache = false;
             if (this.cachedTimes > 0) {
@@ -468,13 +468,13 @@ export class ViewManager {
             }
 
             // Lưu view vào store để quản lý vòng đời (ttl mặc định 30 phút)
-            this.store.set(viewStoreKey, view, this.storeTTL); // lưu view vào store
-            this.store.onExpire(viewStoreKey, (viewStore) => {
-                if (viewStore && viewStore instanceof ViewEngine && viewStore != this.PAGE_VIEW) {
-                    viewStore.__._lifecycleManager.destroy();
-                }
-            });
-            logger.log(`🔍 App.View.loadView: Using new instance view for '${name}' with URL path '${urlPath}'`);
+            // this.store.set(viewStoreKey, view, this.storeTTL); // lưu view vào store
+            // this.store.onExpire(viewStoreKey, (viewStore) => {
+            //     if (viewStore && viewStore instanceof ViewEngine && viewStore != this.PAGE_VIEW) {
+            //         viewStore.__._lifecycleManager.destroy();
+            //     }
+            // });
+            // logger.log(`🔍 App.View.loadView: Using new instance view for '${name}' with URL path '${urlPath}'`);
             // Store view in array for tracking
             this.PAGE_VIEW = view;
             let superView = null;
@@ -602,12 +602,12 @@ export class ViewManager {
             const oldSuperView = this.CURRENT_SUPER_VIEW;
             const oldPageView = this.PAGE_VIEW;
             if (oldSuperView && oldSuperView instanceof ViewEngine) {
-                oldSuperView.__._templateManager.updateHtmlCache();
+                // oldSuperView.__._templateManager.updateHtmlCache();
                 oldSuperView.__._lifecycleManager.unmounted();
             }
             if( oldPageView && oldPageView instanceof ViewEngine && oldPageView != oldSuperView){
-                oldPageView.__._templateManager.updateHtmlCache();
-                oldPageView.__._lifecycleManager.unmounted();
+                // oldPageView.__._templateManager.updateHtmlCache();
+                oldPageView.__._lifecycleManager.destroy();
             }
 
 
@@ -636,7 +636,7 @@ export class ViewManager {
                 oldSuperView.__.removeStyles();
                 oldSuperView.__._templateManager.updateHtmlCache();
             }
-            oldPageView?.__.removeStyles();
+            // oldPageView?.__.removeStyles();
 
 
             // ============================================================
@@ -655,21 +655,21 @@ export class ViewManager {
                 this.emitChangedSections();
             }
 
-            if (newPageView && newPageView instanceof ViewEngine) {
-                newPageView.__.insertStyles();
-                if( isCached && newPageView.__._templateManager.isCached ){
-                    newPageView.__._templateManager.pushCachedSections();
-                    // Re-scan and remount when loading from cache
-                    newPageView.__._renderEngine.rescanAfterCache();
-                }
-            }
-            if (newSuperView && newSuperView instanceof ViewEngine) {
-                newSuperView.__.insertStyles();
-                if( isCached && newSuperView.__._templateManager.isCached ){
-                    // Re-scan and remount superView when loading from cache
-                    newSuperView.__._renderEngine.rescanAfterCache();
-                }
-            }
+            // if (newPageView && newPageView instanceof ViewEngine) {
+            //     newPageView.__.insertStyles();
+            //     if( isCached && newPageView.__._templateManager.isCached ){
+            //         newPageView.__._templateManager.pushCachedSections();
+            //         // Re-scan and remount when loading from cache
+            //         newPageView.__._renderEngine.rescanAfterCache();
+            //     }
+            // }
+            // if (newSuperView && newSuperView instanceof ViewEngine) {
+            //     newSuperView.__.insertStyles();
+            //     if( isCached && newSuperView.__._templateManager.isCached ){
+            //         // Re-scan and remount superView when loading from cache
+            //         newSuperView.__._renderEngine.rescanAfterCache();
+            //     }
+            // }
 
 
             if (viewResult.ultraView && viewResult.ultraView instanceof ViewEngine) {

package/scripts/compiler/test_todo_template.py

@@ -1,83 +0,0 @@
-"""
-Test compiler with real todo template
-"""
-import sys
-from main_compiler import BladeCompiler
-
-# Test template
-template = """
-@vars(['todos'])
-
-<div>
-    <h3>Todo List</h3>
-    <ul class="todo-list">
-        @foreach ($todos as $todo)
-            <li class="todo-item {{ $todo['completed'] ? 'completed' : '' }}">
-                <input type="checkbox" @change(toggleTodo($todo['id'])) @checked($todo['completed'])>
-                {{ $todo['text'] }}
-                <button class="btn btn-sm btn-outline-danger" @click(deleteTodo($todo['id']))>×</button>
-            </li>
-        @endforeach
-    </ul>
-</div>
-"""
-
-# Compile
-compiler = BladeCompiler()
-result = compiler.compile_blade_to_js(template, 'test-todo')
-
-# Debug: Check variable_list
-import re as regex_module
-vars_match = regex_module.search(r"const __VARIABLE_LIST__ = \[(.*?)\]", result)
-if vars_match:
-    print("\n🔍 DEBUG: __VARIABLE_LIST__ =", vars_match.group(1))
-
-print("=" * 80)
-print("INPUT:")
-print(template)
-print("\n" + "=" * 80)
-print("OUTPUT:")
-print(result)
-print("=" * 80)
-
-# Check specific patterns
-output = result
-
-# Check __reactive with type: 'watch'
-if "__reactive(" in output and "{type: 'watch'}" in output:
-    print("✅ __reactive with type: 'watch' found")
-else:
-    print("❌ Missing __reactive with type: 'watch'")
-
-# Check __foreach is inside __reactive
-if "__reactive(" in output and "__foreach(" in output:
-    reactive_pos = output.find("__reactive(")
-    foreach_pos = output.find("__foreach(")
-    if reactive_pos < foreach_pos:
-        print("✅ __foreach is wrapped by __reactive")
-    else:
-        print("❌ __foreach is NOT wrapped by __reactive")
-
-# Check event directives
-if "__addEventConfig" in output:
-    print("✅ Event directives compiled")
-else:
-    print("❌ Event directives missing")
-
-# Check class binding in attribute
-if "todo['completed'] ? 'completed' : ''" in output:
-    print("✅ Class expression compiled")
-else:
-    print("❌ Class expression missing")
-
-# Check @checked directive
-if "checked" in output:
-    print("✅ @checked directive compiled")
-else:
-    print("❌ @checked directive missing")
-
-# Check text interpolation
-if "todo['text']" in output:
-    print("✅ Text interpolation compiled")
-else:
-    print("❌ Text interpolation missing")