Class LifeCycleHook

src/py/reactpy/reactpy/core/_life_cycle_hook.py:33–244

An object which manages the "life cycle" of a layout component. The "life cycle" of a component is the set of events which occur from the time a component is first rendered until it is removed from the layout. The life cycle is ultimately driven by the layout itself, but components can

class LifeCycleHook:
    """An object which manages the "life cycle" of a layout component.

    The "life cycle" of a component is the set of events which occur from the time
    a component is first rendered until it is removed from the layout. The life cycle
    is ultimately driven by the layout itself, but components can "hook" into those
    events to perform actions. Components gain access to their own life cycle hook
    by calling :func:`current_hook`. They can then perform actions such as:

    1. Adding state via :meth:`use_state`
    2. Adding effects via :meth:`add_effect`
    3. Setting or getting context providers via
       :meth:`LifeCycleHook.set_context_provider` and
       :meth:`get_context_provider` respectively.

    Components can request access to their own life cycle events and state through hooks
    while :class:`~reactpy.core.proto.LayoutType` objects drive drive the life cycle
    forward by triggering events and rendering view changes.

    Example:

        If removed from the complexities of a layout, a very simplified full life cycle
        for a single component with no child components would look a bit like this:

        .. testcode::

            from reactpy.core._life_cycle_hook import LifeCycleHook
            from reactpy.core.hooks import current_hook

            # this function will come from a layout implementation
            schedule_render = lambda: ...

            # --- start life cycle ---

            hook = LifeCycleHook(schedule_render)

            # --- start render cycle ---

            component = ...
            await hook.affect_component_will_render(component)
            try:
                # render the component
                ...

                # the component may access the current hook
                assert current_hook() is hook

                # and save state or add effects
                current_hook().use_state(lambda: ...)

                async def my_effect(stop_event):
                    ...

                current_hook().add_effect(my_effect)
            finally:
                await hook.affect_component_did_render()

            # This should only be called after the full set of changes associated with a