Class MemoizeStatefulPlugin

reflex/compiler/plugins/memoize.py:203–402

Auto-memoize stateful components with experimental-memo wrappers. Registered in ``default_page_plugins`` before ``DefaultCollectorPlugin``. Components either render as passthrough memo wrappers or snapshot memo wrappers (see ``get_memoization_strategy``): - Snapshot wrappers (``Mem

@dataclasses.dataclass(frozen=True, slots=True)
class MemoizeStatefulPlugin(Plugin):
    """Auto-memoize stateful components with experimental-memo wrappers.

    Registered in ``default_page_plugins`` before ``DefaultCollectorPlugin``.
    Components either render as passthrough memo wrappers or snapshot memo
    wrappers (see ``get_memoization_strategy``):

    - Snapshot wrappers (``MemoizationLeaf``-style boundaries and structural
      ``Foreach`` wrappers): wrapped in ``enter_component``
      and returned with empty structural children. The walker skips descent, so
      hooks attached to the captured body are compiled into the memo body only.
    - Passthrough wrappers are wrapped in
      ``leave_component`` after descendants have already compiled, so any inner
      memo wrappers flow into this wrapper's children.

    Descendants of a snapshot boundary are never independently memoized; the
    boundary owns the wrapping decision for its whole subtree. This is tracked
    via ``PageContext.memoize_suppressor_stack`` — a stack of component ids
    that pushed suppression, popped in ``leave_component`` when the matching
    component leaves.
    """

    def enter_component(
        self,
        comp: BaseComponent,
        /,
        *,
        page_context: PageContext,
        compile_context: Any,
        in_prop_tree: bool = False,
    ) -> BaseComponent | ComponentAndChildren | None:
        """Memoize snapshot-boundary subtrees before descent.

        Snapshot boundaries (``MemoizationLeaf``-style, see
        ``is_snapshot_boundary``) stash state-referencing hooks inside
        internally-built structural children. If we waited until
        ``leave_component`` to swap the boundary for its memo wrapper, the
        walker would have already descended and the collector plugin would
        have pulled those hooks into page scope. Returning the wrapper with
        empty structural children here causes the walker to skip the descent
        entirely — the boundary's full snapshot lives only in the memo
        component definition compiled separately.

        Non-boundary components are handled in ``leave_component`` so their
        already-compiled children flow into the wrapper.

        Args:
            comp: The component being visited.
            page_context: The active page context.
            compile_context: The active compile context.
            in_prop_tree: Whether the component is in a prop subtree.

        Returns:
            A ``(wrapper, ())`` replacement for memoized boundaries, otherwise
            ``None``.
        """
        if in_prop_tree:
            return None