From aa98f6d58b7578c49716ecc33f83202ff45c6cf6 Mon Sep 17 00:00:00 2001 From: Benedikt Bartscher Date: Fri, 20 Nov 2026 08:31:07 +0100 Subject: [PATCH 1/6] Collect the hooks and imports of the string form Bare renders for objects --- .../src/reflex_components_core/base/bare.py | 28 ++++++++------- tests/units/components/base/test_bare.py | 35 ++++++++++++++++++- 2 files changed, 50 insertions(+), 13 deletions(-) diff --git a/packages/reflex-components-core/src/reflex_components_core/base/bare.py b/packages/reflex-components-core/src/reflex_components_core/base/bare.py index 058952c124a..f133efa6e5a 100644 --- a/packages/reflex-components-core/src/reflex_components_core/base/bare.py +++ b/packages/reflex-components-core/src/reflex_components_core/base/bare.py @@ -180,15 +180,23 @@ def _get_all_refs(self) -> dict[str, None]: refs |= component._get_all_refs() return refs - def _render(self) -> CommonTag: + def _rendered_contents(self) -> Var: + """The var this component renders: booleans and objects as their string form. + + Returns: + The rendered var. + """ contents = ( Var.create(self.contents) if not isinstance(self.contents, Var) else self.contents ) if isinstance(contents, (BooleanVar, ObjectVar)): - return Tagless(contents=f"{contents.to_string()!s}") - return Tagless(contents=f"{contents!s}") + return contents.to_string() + return contents + + def _render(self) -> CommonTag: + return Tagless(contents=f"{self._rendered_contents()!s}") def render(self) -> dict: """Render the component as a dictionary. @@ -198,14 +206,7 @@ def render(self) -> dict: Returns: The rendered component. """ - contents = ( - Var.create(self.contents) - if not isinstance(self.contents, Var) - else self.contents - ) - if isinstance(contents, (BooleanVar, ObjectVar)): - return {"contents": f"{contents.to_string()!s}"} - return {"contents": f"{contents!s}"} + return {"contents": f"{self._rendered_contents()!s}"} def _add_style_recursive( self, style: ComponentStyle, theme: Component | None = None @@ -244,6 +245,9 @@ def _get_vars( ignore_ids: The ids to ignore. Yields: - The contents if it is a Var, otherwise nothing. + The contents, and the var rendered for them when that differs. """ yield self.contents + rendered = self._rendered_contents() + if rendered is not self.contents: + yield rendered diff --git a/tests/units/components/base/test_bare.py b/tests/units/components/base/test_bare.py index 30f3d9b233c..43dad9260d0 100644 --- a/tests/units/components/base/test_bare.py +++ b/tests/units/components/base/test_bare.py @@ -1,5 +1,7 @@ import pytest -from reflex_base.vars.base import Var +from reflex_base.vars import ObjectVar +from reflex_base.vars.base import Var, VarData +from reflex_base.vars.sequence import StringVar from reflex_components_core.base.bare import Bare STATE_VAR = Var(_js_expr="default_state.name") @@ -23,3 +25,34 @@ def test_fstrings(contents, expected): """ comp = Bare.create(contents).render() assert comp["contents"] == expected + + +PICK_HOOK = "const pick = usePick()" + + +class PickedVar(ObjectVar[dict]): + """An object var whose string form needs a hook and an import.""" + + def to_string(self, use_json: bool = True) -> StringVar: + """Pick a text from the object with a hook. + + Args: + use_json: Unused. + + Returns: + The picked text. + """ + return Var( + _js_expr=f"pick({self!s})", + _var_data=VarData( + hooks={PICK_HOOK: None}, imports={"$/utils/pick": ["usePick"]} + ), + ).to(str) + + +def test_rendered_string_form_brings_its_hooks_and_imports(): + """An object rendered through to_string carries that var's hooks and imports.""" + comp = Bare.create(PickedVar(_js_expr="state.texts", _var_type=dict)) + assert comp.render()["contents"] == "pick(state.texts)" + assert PICK_HOOK in comp._get_all_hooks() + assert "$/utils/pick" in comp._get_all_imports() From ecd66076e52a5c12d4cf96aad6d21b823ac2d37b Mon Sep 17 00:00:00 2001 From: Benedikt Bartscher Date: Fri, 20 Nov 2026 08:43:07 +0100 Subject: [PATCH 2/6] Drop Bare's import override, which replaced a library's imports with those of the original var --- .../news/+bare-string-form-deps.bugfix.md | 1 + .../src/reflex_components_core/base/bare.py | 17 ------------- tests/units/components/base/test_bare.py | 24 ++++++++++++++----- 3 files changed, 19 insertions(+), 23 deletions(-) create mode 100644 packages/reflex-components-core/news/+bare-string-form-deps.bugfix.md diff --git a/packages/reflex-components-core/news/+bare-string-form-deps.bugfix.md b/packages/reflex-components-core/news/+bare-string-form-deps.bugfix.md new file mode 100644 index 00000000000..8ba96b8282b --- /dev/null +++ b/packages/reflex-components-core/news/+bare-string-form-deps.bugfix.md @@ -0,0 +1 @@ +An object or boolean Var rendered as a child now brings along the hooks and imports of its `to_string()`, so a Var type with its own string form no longer breaks the page. diff --git a/packages/reflex-components-core/src/reflex_components_core/base/bare.py b/packages/reflex-components-core/src/reflex_components_core/base/bare.py index f133efa6e5a..71a3ef167d8 100644 --- a/packages/reflex-components-core/src/reflex_components_core/base/bare.py +++ b/packages/reflex-components-core/src/reflex_components_core/base/bare.py @@ -11,7 +11,6 @@ from reflex_base.components.tags.tagless import Tagless from reflex_base.environment import PerformanceMode, environment from reflex_base.utils.decorator import once -from reflex_base.utils.imports import ParsedImportDict from reflex_base.vars import BooleanVar, ObjectVar, Var from reflex_base.vars.base import GLOBAL_CACHE, VarData from reflex_base.vars.sequence import LiteralStringVar @@ -103,22 +102,6 @@ def _get_all_hooks(self) -> dict[str, VarData | None]: hooks |= component._get_all_hooks() return hooks - def _get_all_imports(self, collapse: bool = False) -> ParsedImportDict: - """Include the imports for the component. - - Args: - collapse: Whether to collapse the imports. - - Returns: - The imports for the component. - """ - imports = super()._get_all_imports(collapse=collapse) - if isinstance(self.contents, Var): - var_data = self.contents._get_all_var_data() - if var_data: - imports |= {k: list(v) for k, v in var_data.imports} - return imports - def _get_all_dynamic_imports(self) -> set[str]: """Get dynamic imports for the component. diff --git a/tests/units/components/base/test_bare.py b/tests/units/components/base/test_bare.py index 43dad9260d0..577b229ef11 100644 --- a/tests/units/components/base/test_bare.py +++ b/tests/units/components/base/test_bare.py @@ -1,4 +1,5 @@ import pytest +from reflex_base.utils.imports import ImportVar from reflex_base.vars import ObjectVar from reflex_base.vars.base import Var, VarData from reflex_base.vars.sequence import StringVar @@ -27,11 +28,12 @@ def test_fstrings(contents, expected): assert comp["contents"] == expected +TEXTS_HOOK = "const texts = useTexts()" PICK_HOOK = "const pick = usePick()" class PickedVar(ObjectVar[dict]): - """An object var whose string form needs a hook and an import.""" + """An object var whose string form needs another hook from the same library.""" def to_string(self, use_json: bool = True) -> StringVar: """Pick a text from the object with a hook. @@ -45,14 +47,24 @@ def to_string(self, use_json: bool = True) -> StringVar: return Var( _js_expr=f"pick({self!s})", _var_data=VarData( - hooks={PICK_HOOK: None}, imports={"$/utils/pick": ["usePick"]} + hooks={PICK_HOOK: None}, imports={"$/utils/i18n": ["usePick"]} ), ).to(str) def test_rendered_string_form_brings_its_hooks_and_imports(): """An object rendered through to_string carries that var's hooks and imports.""" - comp = Bare.create(PickedVar(_js_expr="state.texts", _var_type=dict)) - assert comp.render()["contents"] == "pick(state.texts)" - assert PICK_HOOK in comp._get_all_hooks() - assert "$/utils/pick" in comp._get_all_imports() + texts = PickedVar( + _js_expr="texts", + _var_type=dict, + _var_data=VarData( + hooks={TEXTS_HOOK: None}, imports={"$/utils/i18n": ["useTexts"]} + ), + ) + comp = Bare.create(texts) + + assert comp.render()["contents"] == "pick(texts)" + assert comp._get_all_hooks() == {TEXTS_HOOK: None, PICK_HOOK: None} + assert comp._get_all_imports(collapse=True) == { + "$/utils/i18n": [ImportVar(tag="useTexts"), ImportVar(tag="usePick")] + } From 31e402a0b84fc0fdd4d9c49e86b34a64a541cff7 Mon Sep 17 00:00:00 2001 From: Benedikt Bartscher Date: Fri, 20 Nov 2026 23:14:00 +0100 Subject: [PATCH 3/6] Build a Bare's rendered var once and reuse it Bare._get_vars, _render and render each rebuilt the rendered var, so a boolean or object Bare made a new to_string() var on every call (about four _get_vars calls per Bare in a page compile), and each new var missed the _get_all_var_data cache. The contents and rendered var now live in the base class's _vars_cache, which _clear_compile_caches and deepcopy already drop, keyed on the contents so a reassigned contents is rendered afresh. Per call, bool/object: _get_vars 2.9 us -> 0.16 us, render 4.6 us -> 0.77 us; string/literal _get_vars 246 ns -> 155 ns. A full page compile with 400 Bares (200 bool/object) goes from ~48 ms to ~45 ms (~42 ms before this PR, the rest being the rendered var's hooks and imports this PR now collects). --- .../src/reflex_components_core/base/bare.py | 37 ++++++++++--------- tests/units/components/base/test_bare.py | 22 +++++++++++ 2 files changed, 42 insertions(+), 17 deletions(-) diff --git a/packages/reflex-components-core/src/reflex_components_core/base/bare.py b/packages/reflex-components-core/src/reflex_components_core/base/bare.py index 71a3ef167d8..7f87474df73 100644 --- a/packages/reflex-components-core/src/reflex_components_core/base/bare.py +++ b/packages/reflex-components-core/src/reflex_components_core/base/bare.py @@ -163,23 +163,29 @@ def _get_all_refs(self) -> dict[str, None]: refs |= component._get_all_refs() return refs - def _rendered_contents(self) -> Var: - """The var this component renders: booleans and objects as their string form. + def _contents_vars(self) -> tuple[Var, ...]: + """The contents and, when it differs, the var rendered for them, built once. + + The rendered var shows booleans and objects as their string form. Returns: - The rendered var. + The vars, the rendered one last. """ - contents = ( - Var.create(self.contents) - if not isinstance(self.contents, Var) - else self.contents - ) - if isinstance(contents, (BooleanVar, ObjectVar)): - return contents.to_string() - return contents + contents = self.contents + cached = self.__dict__.get("_vars_cache") + # The base class's vars cache, dropped with the other compile caches; + # keyed on the contents too, so reassigning them never renders stale. + if cached is not None and cached[0] is contents: + return cached + rendered = contents if isinstance(contents, Var) else Var.create(contents) + if isinstance(rendered, (BooleanVar, ObjectVar)): + rendered = rendered.to_string() + cached = (contents,) if rendered is contents else (contents, rendered) + self._vars_cache = cached + return cached def _render(self) -> CommonTag: - return Tagless(contents=f"{self._rendered_contents()!s}") + return Tagless(contents=f"{self._contents_vars()[-1]!s}") def render(self) -> dict: """Render the component as a dictionary. @@ -189,7 +195,7 @@ def render(self) -> dict: Returns: The rendered component. """ - return {"contents": f"{self._rendered_contents()!s}"} + return {"contents": f"{self._contents_vars()[-1]!s}"} def _add_style_recursive( self, style: ComponentStyle, theme: Component | None = None @@ -230,7 +236,4 @@ def _get_vars( Yields: The contents, and the var rendered for them when that differs. """ - yield self.contents - rendered = self._rendered_contents() - if rendered is not self.contents: - yield rendered + yield from self._contents_vars() diff --git a/tests/units/components/base/test_bare.py b/tests/units/components/base/test_bare.py index 577b229ef11..a10b3c6c72c 100644 --- a/tests/units/components/base/test_bare.py +++ b/tests/units/components/base/test_bare.py @@ -1,4 +1,5 @@ import pytest +from reflex_base.components.tags.tagless import Tagless from reflex_base.utils.imports import ImportVar from reflex_base.vars import ObjectVar from reflex_base.vars.base import Var, VarData @@ -68,3 +69,24 @@ def test_rendered_string_form_brings_its_hooks_and_imports(): assert comp._get_all_imports(collapse=True) == { "$/utils/i18n": [ImportVar(tag="useTexts"), ImportVar(tag="usePick")] } + + +def test_string_form_is_built_once_per_contents(): + """The string form is built once per contents and shared by the vars and the render.""" + comp = Bare.create(Var(_js_expr="flag", _var_type=bool).guess_type()) + assert isinstance(comp, Bare) + contents, rendered = comp._get_vars() + + assert contents is comp.contents + assert tuple(map(id, comp._get_vars())) == (id(contents), id(rendered)) + assert str(rendered) == "(JSON.stringify(flag))" + assert comp.render() == {"contents": "(JSON.stringify(flag))"} + assert comp._render() == Tagless(contents="(JSON.stringify(flag))") + + comp.contents = Var(_js_expr="items", _var_type=dict).guess_type() + + assert comp.render() == {"contents": "(JSON.stringify(items))"} + assert [str(var) for var in comp._get_vars()] == [ + "items", + "(JSON.stringify(items))", + ] From 8c4780aa48713a185cf0ecdf6eae7d1c49e3167a Mon Sep 17 00:00:00 2001 From: Benedikt Bartscher Date: Sat, 21 Nov 2026 00:18:50 +0100 Subject: [PATCH 4/6] Collect the components of a Bare's rendered var too, not only those of its contents --- .../src/reflex_components_core/base/bare.py | 64 +++++++++++-------- tests/units/components/base/test_bare.py | 57 +++++++++++++++++ 2 files changed, 93 insertions(+), 28 deletions(-) diff --git a/packages/reflex-components-core/src/reflex_components_core/base/bare.py b/packages/reflex-components-core/src/reflex_components_core/base/bare.py index 7f87474df73..ffb5f6c6ab0 100644 --- a/packages/reflex-components-core/src/reflex_components_core/base/bare.py +++ b/packages/reflex-components-core/src/reflex_components_core/base/bare.py @@ -85,9 +85,8 @@ def _get_all_hooks_internal(self) -> dict[str, VarData | None]: The hooks for the component. """ hooks = super()._get_all_hooks_internal() - if isinstance(self.contents, Var): - for component in _components_from_var(self.contents): - hooks |= component._get_all_hooks_internal() + for component in self._contents_components(): + hooks |= component._get_all_hooks_internal() return hooks def _get_all_hooks(self) -> dict[str, VarData | None]: @@ -97,9 +96,8 @@ def _get_all_hooks(self) -> dict[str, VarData | None]: The hooks for the component. """ hooks = super()._get_all_hooks() - if isinstance(self.contents, Var): - for component in _components_from_var(self.contents): - hooks |= component._get_all_hooks() + for component in self._contents_components(): + hooks |= component._get_all_hooks() return hooks def _get_all_dynamic_imports(self) -> set[str]: @@ -109,9 +107,8 @@ def _get_all_dynamic_imports(self) -> set[str]: The dynamic imports. """ dynamic_imports = super()._get_all_dynamic_imports() - if isinstance(self.contents, Var): - for component in _components_from_var(self.contents): - dynamic_imports |= component._get_all_dynamic_imports() + for component in self._contents_components(): + dynamic_imports |= component._get_all_dynamic_imports() return dynamic_imports def _get_all_custom_code(self) -> dict[str, None]: @@ -121,9 +118,8 @@ def _get_all_custom_code(self) -> dict[str, None]: The custom code. """ custom_code = super()._get_all_custom_code() - if isinstance(self.contents, Var): - for component in _components_from_var(self.contents): - custom_code |= component._get_all_custom_code() + for component in self._contents_components(): + custom_code |= component._get_all_custom_code() return custom_code def _get_all_app_wrap_components( @@ -141,14 +137,13 @@ def _get_all_app_wrap_components( app_wrap_components = super()._get_all_app_wrap_components( ignore_ids=ignore_ids ) - if isinstance(self.contents, Var): - for component in _components_from_var(self.contents): - component_id = id(component) - if isinstance(component, Component) and component_id not in ignore_ids: - ignore_ids.add(component_id) - app_wrap_components |= component._get_all_app_wrap_components( - ignore_ids=ignore_ids - ) + for component in self._contents_components(): + component_id = id(component) + if isinstance(component, Component) and component_id not in ignore_ids: + ignore_ids.add(component_id) + app_wrap_components |= component._get_all_app_wrap_components( + ignore_ids=ignore_ids + ) return app_wrap_components def _get_all_refs(self) -> dict[str, None]: @@ -158,9 +153,8 @@ def _get_all_refs(self) -> dict[str, None]: The refs for the children. """ refs = super()._get_all_refs() - if isinstance(self.contents, Var): - for component in _components_from_var(self.contents): - refs |= component._get_all_refs() + for component in self._contents_components(): + refs |= component._get_all_refs() return refs def _contents_vars(self) -> tuple[Var, ...]: @@ -184,6 +178,21 @@ def _contents_vars(self) -> tuple[Var, ...]: self._vars_cache = cached return cached + def _contents_components(self) -> Iterator[BaseComponent]: + """The components carried by the contents and the var rendered for them. + + A custom ``to_string()`` can bring components the contents lack. + + Yields: + Each component once, those of the contents first. + """ + seen: set[int] = set() + for var in self._contents_vars(): + for component in _components_from_var(var): + if id(component) not in seen: + seen.add(id(component)) + yield component + def _render(self) -> CommonTag: return Tagless(contents=f"{self._contents_vars()[-1]!s}") @@ -213,11 +222,10 @@ def _add_style_recursive( are_components_touched = False - if isinstance(self.contents, Var): - for component in _components_from_var(self.contents): - if isinstance(component, Component): - component._add_style_recursive(style, theme) - are_components_touched = True + for component in self._contents_components(): + if isinstance(component, Component): + component._add_style_recursive(style, theme) + are_components_touched = True if are_components_touched: GLOBAL_CACHE.clear() diff --git a/tests/units/components/base/test_bare.py b/tests/units/components/base/test_bare.py index a10b3c6c72c..07a2dd8c0c8 100644 --- a/tests/units/components/base/test_bare.py +++ b/tests/units/components/base/test_bare.py @@ -1,4 +1,5 @@ import pytest +from reflex_base.components.component import Component from reflex_base.components.tags.tagless import Tagless from reflex_base.utils.imports import ImportVar from reflex_base.vars import ObjectVar @@ -90,3 +91,59 @@ def test_string_form_is_built_once_per_contents(): "items", "(JSON.stringify(items))", ] + + +BOX_HOOK = "const box = useBox()" +BOX_CODE = "const boxDefaults = {};" + + +class HookedBox(Component): + """A component with a hook and custom code of its own.""" + + tag = "HookedBox" + library = "hooked-box" + + def add_hooks(self) -> list[str]: + """Add the box hook. + + Returns: + The hooks. + """ + return [BOX_HOOK] + + def add_custom_code(self) -> list[str]: + """Add the box defaults. + + Returns: + The custom code. + """ + return [BOX_CODE] + + +class BoxedVar(ObjectVar[dict]): + """An object var whose string form renders through a component.""" + + def to_string(self, use_json: bool = True) -> StringVar: + """Render the object through a box component. + + Args: + use_json: Unused. + + Returns: + The boxed text. + """ + return Var( + _js_expr=f"box({self!s})", + _var_data=VarData(components=(HookedBox.create(id="box"),)), + ).to(str) + + +def test_rendered_string_form_brings_its_components(): + """Components carried by the string form count like those of the contents.""" + comp = Bare.create(BoxedVar(_js_expr="data", _var_type=dict)) + + assert comp.render()["contents"] == "box(data)" + assert BOX_HOOK in comp._get_all_hooks() + assert BOX_CODE in comp._get_all_custom_code() + assert comp._get_all_refs() == HookedBox.create(id="box")._get_all_refs() + assert comp._get_all_refs() From 5b67a35c521a243142da7fe926be1083fd1a7f1a Mon Sep 17 00:00:00 2001 From: Benedikt Bartscher Date: Sat, 21 Nov 2026 10:15:08 +0100 Subject: [PATCH 5/6] Compare the complete hooks, custom code and refs in the rendered-components Bare test --- tests/units/components/base/test_bare.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/tests/units/components/base/test_bare.py b/tests/units/components/base/test_bare.py index 07a2dd8c0c8..d1bb9d7e853 100644 --- a/tests/units/components/base/test_bare.py +++ b/tests/units/components/base/test_bare.py @@ -143,7 +143,9 @@ def test_rendered_string_form_brings_its_components(): comp = Bare.create(BoxedVar(_js_expr="data", _var_type=dict)) assert comp.render()["contents"] == "box(data)" - assert BOX_HOOK in comp._get_all_hooks() - assert BOX_CODE in comp._get_all_custom_code() - assert comp._get_all_refs() == HookedBox.create(id="box")._get_all_refs() - assert comp._get_all_refs() + assert comp._get_all_hooks() == { + 'const ref_box = useRegisteredRef("ref_box");': None, + BOX_HOOK: None, + } + assert comp._get_all_custom_code() == {BOX_CODE: None} + assert comp._get_all_refs() == {"ref_box": None} From e9ef4d74a320595b783e8b13a64ebebd62de24f3 Mon Sep 17 00:00:00 2001 From: Benedikt Bartscher Date: Sat, 21 Nov 2026 20:34:57 +0100 Subject: [PATCH 6/6] Reach the components of a Bare's rendered var through its prop traversal, so their imports count too --- .../src/reflex_components_core/base/bare.py | 43 ++++++------------- tests/units/components/base/test_bare.py | 6 +++ 2 files changed, 20 insertions(+), 29 deletions(-) diff --git a/packages/reflex-components-core/src/reflex_components_core/base/bare.py b/packages/reflex-components-core/src/reflex_components_core/base/bare.py index ffb5f6c6ab0..3bfd1968438 100644 --- a/packages/reflex-components-core/src/reflex_components_core/base/bare.py +++ b/packages/reflex-components-core/src/reflex_components_core/base/bare.py @@ -2,6 +2,7 @@ from __future__ import annotations +import functools import logging from collections.abc import Iterator, Sequence from typing import Any @@ -100,28 +101,6 @@ def _get_all_hooks(self) -> dict[str, VarData | None]: hooks |= component._get_all_hooks() return hooks - def _get_all_dynamic_imports(self) -> set[str]: - """Get dynamic imports for the component. - - Returns: - The dynamic imports. - """ - dynamic_imports = super()._get_all_dynamic_imports() - for component in self._contents_components(): - dynamic_imports |= component._get_all_dynamic_imports() - return dynamic_imports - - def _get_all_custom_code(self) -> dict[str, None]: - """Get custom code for the component. - - Returns: - The custom code. - """ - custom_code = super()._get_all_custom_code() - for component in self._contents_components(): - custom_code |= component._get_all_custom_code() - return custom_code - def _get_all_app_wrap_components( self, *, ignore_ids: set[int] | None = None ) -> dict[tuple[int, str], Component]: @@ -146,16 +125,22 @@ def _get_all_app_wrap_components( ) return app_wrap_components - def _get_all_refs(self) -> dict[str, None]: - """Get the refs for the children of the component. + @functools.cached_property + def _get_component_prop_property(self) -> Sequence[BaseComponent]: + """The components of the props and of the var rendered for the contents. + + The compiler and the import, custom code, dynamic import and ref collectors + follow this traversal, so components a custom ``to_string()`` brings count. Returns: - The refs for the children. + Each component of the props, then the rendered var's others. """ - refs = super()._get_all_refs() - for component in self._contents_components(): - refs |= component._get_all_refs() - return refs + components = super()._get_component_prop_property + seen = {id(component) for component in components} + return [ + *components, + *(c for c in self._contents_components() if id(c) not in seen), + ] def _contents_vars(self) -> tuple[Var, ...]: """The contents and, when it differs, the var rendered for them, built once. diff --git a/tests/units/components/base/test_bare.py b/tests/units/components/base/test_bare.py index d1bb9d7e853..04c063715b6 100644 --- a/tests/units/components/base/test_bare.py +++ b/tests/units/components/base/test_bare.py @@ -149,3 +149,9 @@ def test_rendered_string_form_brings_its_components(): } assert comp._get_all_custom_code() == {BOX_CODE: None} assert comp._get_all_refs() == {"ref_box": None} + # the compiler reaches the box's imports through the prop traversal too + assert [type(c) for c in comp._get_components_in_props()] == [HookedBox] + assert comp._get_all_imports(collapse=True) == { + "$/utils/state": [ImportVar(tag="useRegisteredRef")], + "hooked-box": [ImportVar(tag="HookedBox")], + }