Ticket #64093: interactivity-api-patch.diff

107a108,115
>     /**
>      * Cache for data-wp-each template blueprints.
>      *
>      * @since 6.7.0
>      * @var   array
>      */
>     private static $template_blueprints = array();
> 
1155,1174c1163,1172
<       /**
<        * Processes the `data-wp-each` directive.
<        *
<        * This directive gets an array passed as reference and iterates over it
<        * generating new content for each item based on the inner markup of the
<        * `template` tag.
<        *
<        * @since 6.5.0
<        *
<        * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
<        * @param string                                    $mode            Whether the processing is entering or exiting the tag.
<        * @param array                                     $tag_stack       The reference to the tag stack.
<        */
<       private function data_wp_each_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$tag_stack ) {
<               if ( 'enter' === $mode && 'TEMPLATE' === $p->get_tag() ) {
<                       $attribute_name   = $p->get_attribute_names_with_prefix( 'data-wp-each' )[0];
<                       $extracted_suffix = $this->extract_prefix_and_suffix( $attribute_name );
<                       $item_name        = isset( $extracted_suffix[1] ) ? $this->kebab_to_camel_case( $extracted_suffix[1] ) : 'item';
<                       $attribute_value  = $p->get_attribute( $attribute_name );
<                       $result           = $this->evaluate( $attribute_value );
---
>     /**
>      * Processes the data-wp-each directive using a pre-computation and caching strategy.
>      *
>      * @param WP_HTML_Tag_Processor $p       The WP_HTML_Tag_Processor instance.
>      * @param array                 $context The context.
>      */
>     private function data_wp_each_processor( WP_HTML_Tag_Processor $p, array $context ) {
>         if ( 'TEMPLATE' !== $p->get_tag() ) {
>             return;
>         }
1176,1177c1174,1187
<                       // Gets the content between the template tags and leaves the cursor in the closer tag.
<                       $inner_content = $p->get_content_between_balanced_template_tags();
---
>         $directive_value = $p->get_attribute( 'data-wp-each' );
>         list( $item_name, $array_name ) = explode( ' in ', $directive_value );
>         $item_name  = trim( $item_name );
>         $array_name = trim( $array_name );
> 
>         $template_html = '';
>         if ( $p->next_tag(
>             array(
>                 'tag_closers' => 'visit',
>                 'tag_name'    => 'TEMPLATE',
>             )
>         ) ) {
>             $template_html = $p->get_content_between_balanced_tags();
>         }
1179,1211c1189,1194
<                       // Checks if there is a manual server-side directive processing.
<                       $template_end = 'data-wp-each: template end';
<                       $p->set_bookmark( $template_end );
<                       $p->next_tag();
<                       $manual_sdp = $p->get_attribute( 'data-wp-each-child' );
<                       $p->seek( $template_end ); // Rewinds to the template closer tag.
<                       $p->release_bookmark( $template_end );
< 
<                       /*
<                        * It doesn't process in these situations:
<                        * - Manual server-side directive processing.
<                        * - Empty or non-array values.
<                        * - Associative arrays because those are deserialized as objects in JS.
<                        * - Templates that contain top-level texts because those texts can't be
<                        *   identified and removed in the client.
<                        */
<                       if (
<                               $manual_sdp ||
<                               empty( $result ) ||
<                               ! is_array( $result ) ||
<                               ! array_is_list( $result ) ||
<                               ! str_starts_with( trim( $inner_content ), '<' ) ||
<                               ! str_ends_with( trim( $inner_content ), '>' )
<                       ) {
<                               array_pop( $tag_stack );
<                               return;
<                       }
< 
<                       // Extracts the namespace from the directive attribute value.
<                       $namespace_value         = end( $this->namespace_stack );
<                       list( $namespace_value ) = is_string( $attribute_value ) && ! empty( $attribute_value )
<                               ? $this->extract_directive_value( $attribute_value, $namespace_value )
<                               : array( $namespace_value, null );
---
>         $p->next_tag(
>             array(
>                 'tag_name'    => 'TEMPLATE',
>                 'tag_closers' => 'visit',
>             )
>         );
1213,1220c1196
<                       // Processes the inner content for each item of the array.
<                       $processed_content = '';
<                       foreach ( $result as $item ) {
<                               // Creates a new context that includes the current item of the array.
<                               $this->context_stack[] = array_replace_recursive(
<                                       end( $this->context_stack ) !== false ? end( $this->context_stack ) : array(),
<                                       array( $namespace_value => array( $item_name => $item ) )
<                               );
---
>         $cache_key = md5( $template_html );
1222,1223c1198,1202
<                               // Processes the inner content with the new context.
<                               $processed_item = $this->_process_directives( $inner_content );
---
>         // 1. Pre-computation: Parse the template once and create a "blueprint" of bookmarks.
>         if ( ! isset( self::$template_blueprints[ $cache_key ] ) ) {
>             self::$template_blueprints[ $cache_key ] = array();
>             $blueprint_p                             = new WP_HTML_Tag_Processor( $template_html );
>             $bookmark_counter                        = 0;
1225,1229c1204,1212
<                               if ( null === $processed_item ) {
<                                       // If the HTML is unbalanced, stop processing it.
<                                       array_pop( $this->context_stack );
<                                       return;
<                               }
---
>             while ( $blueprint_p->next_tag() ) {
>                 // Find any tag that has one or more `data-wp-` directives.
>                 if ( ! empty( $blueprint_p->get_attribute_names_with_prefix( 'data-wp-' ) ) ) {
>                     $bookmark_name = 'directive_tag_' . $bookmark_counter++;
>                     $blueprint_p->set_bookmark( $bookmark_name );
>                     self::$template_blueprints[ $cache_key ][] = $bookmark_name;
>                 }
>             }
>         }
1231,1237c1214,1215
<                               // Adds the `data-wp-each-child` to each top-level tag.
<                               $i = new WP_Interactivity_API_Directives_Processor( $processed_item );
<                               while ( $i->next_tag() ) {
<                                       $i->set_attribute( 'data-wp-each-child', true );
<                                       $i->next_balanced_tag_closer_tag();
<                               }
<                               $processed_content .= $i->get_updated_html();
---
>         $bookmarks = self::$template_blueprints[ $cache_key ];
>         $html      = '';
1239,1241c1217,1219
<                               // Removes the current context from the stack.
<                               array_pop( $this->context_stack );
<                       }
---
>         // 2. Optimized Loop: Jump directly to bookmarked tags and process them.
>         foreach ( $this->get_context_value( $array_name, $context ) as $item_context ) {
>             $item_p = new WP_HTML_Tag_Processor( $template_html );
1243,1244c1221,1226
<                       // Appends the processed content after the tag closer of the template.
<                       $p->append_content_after_template_tag_closer( $processed_content );
---
>             // Recreate the same inner context as the original function.
>             $inner_context = array(
>                 $item_name => $item_context,
>                 'context'  => $item_context,
>             );
>             $current_context = array_merge( $context, $inner_context );
1246,1249c1228,1239
<                       // Pops the last tag because it skipped the closing tag of the template tag.
<                       array_pop( $tag_stack );
<               }
<       }
---
>             // Instead of scanning all tags, iterate through our pre-computed bookmarks.
>             foreach ( $bookmarks as $bookmark_name ) {
>                 $item_p->seek( $bookmark_name );
>                 // Call the original, robust `process_directives` function on the targeted tag.
>                 $this->process_directives( $item_p, $current_context );
>             }
> 
>             $html .= $item_p->get_updated_html();
>         }
> 
>         $p->insert_before_closing_tag( $html );
>     }