reflex 0.6.0__py3-none-any.whl → 0.6.0a1__py3-none-any.whl

reflex/{vars → ivars}/base.py

@@ -9,11 +9,7 @@ import dis
 import functools
 import inspect
 import json
-import random
-import re
-import string
 import sys
-import warnings
 from types import CodeType, FunctionType
 from typing import (
     TYPE_CHECKING,
@@ -21,7 +17,6 @@ from typing import (
     Callable,
     Dict,
     Generic,
-    Iterable,
     List,
     Literal,
     NoReturn,
@@ -48,14 +43,15 @@ from reflex.utils.exceptions import (
     VarValueError,
 )
 from reflex.utils.format import format_state_name
-from reflex.utils.imports import (
-    ImmutableParsedImportDict,
-    ImportDict,
-    ImportVar,
-    ParsedImportDict,
-    parse_imports,
-)
 from reflex.utils.types import GenericType, Self, get_origin
+from reflex.vars import (
+    REPLACED_NAMES,
+    Var,
+    VarData,
+    _decode_var_immutable,
+    _extract_var_data,
+    _global_vars,
+)
 
 if TYPE_CHECKING:
     from reflex.state import BaseState
@@ -71,20 +67,19 @@ if TYPE_CHECKING:
     from .sequence import ArrayVar, StringVar, ToArrayOperation, ToStringOperation
 
 
-VAR_TYPE = TypeVar("VAR_TYPE", covariant=True)
-
-warnings.filterwarnings("ignore", message="fields may not start with an underscore")
+VAR_TYPE = TypeVar("VAR_TYPE")
 
 
 @dataclasses.dataclass(
     eq=False,
     frozen=True,
+    **{"slots": True} if sys.version_info >= (3, 10) else {},
 )
-class Var(Generic[VAR_TYPE]):
+class ImmutableVar(Var, Generic[VAR_TYPE]):
     """Base class for immutable vars."""
 
     # The name of the var.
-    _js_expr: str = dataclasses.field()
+    _var_name: str = dataclasses.field()
 
     # The type of the var.
     _var_type: types.GenericType = dataclasses.field(default=Any)
@@ -98,7 +93,7 @@ class Var(Generic[VAR_TYPE]):
         Returns:
             The name of the var.
         """
-        return self._js_expr
+        return self._var_name
 
     @property
     def _var_is_local(self) -> bool:
@@ -109,26 +104,6 @@ class Var(Generic[VAR_TYPE]):
         """
         return False
 
-    @property
-    @deprecated("Use `_js_expr` instead.")
-    def _var_name(self) -> str:
-        """The name of the var.
-
-        Returns:
-            The name of the var.
-        """
-        return self._js_expr
-
-    @property
-    @deprecated("Use `_js_expr` instead.")
-    def _var_name_unwrapped(self) -> str:
-        """The name of the var without extra curly braces.
-
-        Returns:
-            The name of the var.
-        """
-        return self._js_expr
-
     @property
     def _var_is_string(self) -> bool:
         """Whether the var is a string literal.
@@ -141,11 +116,11 @@ class Var(Generic[VAR_TYPE]):
     def __post_init__(self):
         """Post-initialize the var."""
         # Decode any inline Var markup and apply it to the instance
-        _var_data, _js_expr = _decode_var_immutable(self._js_expr)
+        _var_data, _var_name = _decode_var_immutable(self._var_name)
 
-        if _var_data or _js_expr != self._js_expr:
+        if _var_data or _var_name != self._var_name:
             self.__init__(
-                _js_expr=_js_expr,
+                _var_name=_var_name,
                 _var_type=self._var_type,
                 _var_data=VarData.merge(self._var_data, _var_data),
             )
@@ -156,7 +131,7 @@ class Var(Generic[VAR_TYPE]):
         Returns:
             The hash of the var.
         """
-        return hash((self._js_expr, self._var_type, self._var_data))
+        return hash((self._var_name, self._var_type, self._var_data))
 
     def _get_all_var_data(self) -> VarData | None:
         """Get all VarData associated with the Var.
@@ -166,7 +141,7 @@ class Var(Generic[VAR_TYPE]):
         """
         return self._var_data
 
-    def equals(self, other: Var) -> bool:
+    def equals(self, other: ImmutableVar) -> bool:
         """Check if two vars are equal.
 
         Args:
@@ -176,7 +151,7 @@ class Var(Generic[VAR_TYPE]):
             Whether the vars are equal.
         """
         return (
-            self._js_expr == other._js_expr
+            self._var_name == other._var_name
             and self._var_type == other._var_type
             and self._get_all_var_data() == other._get_all_var_data()
         )
@@ -189,20 +164,24 @@ class Var(Generic[VAR_TYPE]):
             **kwargs: Var fields to update.
 
         Returns:
-            A new Var with the updated fields overwriting the corresponding fields in this Var.
+            A new ImmutableVar with the updated fields overwriting the corresponding fields in this Var.
 
         Raises:
             TypeError: If _var_is_local, _var_is_string, or _var_full_name_needs_state_prefix is not None.
         """
         if kwargs.get("_var_is_local", False) is not False:
-            raise TypeError("The _var_is_local argument is not supported for Var.")
+            raise TypeError(
+                "The _var_is_local argument is not supported for ImmutableVar."
+            )
 
         if kwargs.get("_var_is_string", False) is not False:
-            raise TypeError("The _var_is_string argument is not supported for Var.")
+            raise TypeError(
+                "The _var_is_string argument is not supported for ImmutableVar."
+            )
 
         if kwargs.get("_var_full_name_needs_state_prefix", False) is not False:
             raise TypeError(
-                "The _var_full_name_needs_state_prefix argument is not supported for Var."
+                "The _var_full_name_needs_state_prefix argument is not supported for ImmutableVar."
             )
 
         return dataclasses.replace(
@@ -220,7 +199,7 @@ class Var(Generic[VAR_TYPE]):
         _var_is_local: bool | None = None,
         _var_is_string: bool | None = None,
         _var_data: VarData | None = None,
-    ) -> Var:
+    ) -> ImmutableVar | None:
         """Create a var from a value.
 
         Args:
@@ -231,57 +210,80 @@ class Var(Generic[VAR_TYPE]):
 
         Returns:
             The var.
+
+        Raises:
+            VarTypeError: If the value is JSON-unserializable.
+            TypeError: If _var_is_local or _var_is_string is not None.
         """
         if _var_is_local is not None:
-            console.deprecate(
-                feature_name="_var_is_local",
-                reason="The _var_is_local argument is not supported for Var."
-                "If you want to create a Var from a raw Javascript expression, use the constructor directly",
-                deprecation_version="0.6.0",
-                removal_version="0.7.0",
+            raise TypeError(
+                "The _var_is_local argument is not supported for ImmutableVar."
             )
+
         if _var_is_string is not None:
-            console.deprecate(
-                feature_name="_var_is_string",
-                reason="The _var_is_string argument is not supported for Var."
-                "If you want to create a Var from a raw Javascript expression, use the constructor directly",
-                deprecation_version="0.6.0",
-                removal_version="0.7.0",
+            raise TypeError(
+                "The _var_is_string argument is not supported for ImmutableVar."
             )
 
+        from reflex.utils import format
+
+        # Check for none values.
+        if value is None:
+            return None
+
         # If the value is already a var, do nothing.
-        if isinstance(value, Var):
+        if isinstance(value, ImmutableVar):
             return value
 
         # Try to pull the imports and hooks from contained values.
         if not isinstance(value, str):
-            return LiteralVar.create(value)
+            _var_data = VarData.merge(*_extract_var_data(value), _var_data)
 
-        if _var_is_string is False or _var_is_local is True:
-            return cls(
-                _js_expr=value,
-                _var_data=_var_data,
+        # Try to serialize the value.
+        type_ = type(value)
+        if type_ in types.JSONType:
+            name = value
+        else:
+            name, _serialized_type = serializers.serialize(value, get_type=True)
+        if name is None:
+            raise VarTypeError(
+                f"No JSON serializer found for var {value} of type {type_}."
             )
+        name = name if isinstance(name, str) else format.json_dumps(name)
 
-        return LiteralVar.create(value, _var_data=_var_data)
+        return cls(
+            _var_name=name,
+            _var_type=type_,
+            _var_data=_var_data,
+        )
 
     @classmethod
-    @deprecated("Use `.create()` instead.")
     def create_safe(
         cls,
-        *args: Any,
-        **kwargs: Any,
-    ) -> Var:
-        """Create a var from a value.
+        value: Any,
+        _var_is_local: bool | None = None,
+        _var_is_string: bool | None = None,
+        _var_data: VarData | None = None,
+    ) -> ImmutableVar:
+        """Create a var from a value, asserting that it is not None.
 
         Args:
-            *args: The arguments to create the var from.
-            **kwargs: The keyword arguments to create the var from.
+            value: The value to create the var from.
+            _var_is_local: Whether the var is local. Deprecated.
+            _var_is_string: Whether the var is a string literal. Deprecated.
+            _var_data: Additional hooks and imports associated with the Var.
 
         Returns:
             The var.
         """
-        return cls.create(*args, **kwargs)
+        var = cls.create(
+            value,
+            _var_is_local=_var_is_local,
+            _var_is_string=_var_is_string,
+            _var_data=_var_data,
+        )
+        assert var is not None
+        return var
 
     def __format__(self, format_spec: str) -> str:
         """Format the var into a Javascript equivalent to an f-string.
@@ -297,7 +299,7 @@ class Var(Generic[VAR_TYPE]):
         _global_vars[hashed_var] = self
 
         # Encode the _var_data into the formatted output for tracking purposes.
-        return f"{constants.REFLEX_VAR_OPENING_TAG}{hashed_var}{constants.REFLEX_VAR_CLOSING_TAG}{self._js_expr}"
+        return f"{constants.REFLEX_VAR_OPENING_TAG}{hashed_var}{constants.REFLEX_VAR_CLOSING_TAG}{self._var_name}"
 
     @overload
     def to(self, output: Type[StringVar]) -> ToStringOperation: ...
@@ -341,7 +343,7 @@ class Var(Generic[VAR_TYPE]):
         self,
         output: Type[OUTPUT] | types.GenericType,
         var_type: types.GenericType | None = None,
-    ) -> Var:
+    ) -> ImmutableVar:
         """Convert the var to a different type.
 
         Args:
@@ -385,12 +387,6 @@ class Var(Generic[VAR_TYPE]):
             return self.to(BooleanVar, output)
         if fixed_output_type is None:
             return ToNoneOperation.create(self)
-        if issubclass(fixed_output_type, Base):
-            return self.to(ObjectVar, output)
-        if dataclasses.is_dataclass(fixed_output_type) and not issubclass(
-            fixed_output_type, Var
-        ):
-            return self.to(ObjectVar, output)
 
         if issubclass(output, BooleanVar):
             return ToBooleanVarOperation.create(self)
@@ -425,9 +421,6 @@ class Var(Generic[VAR_TYPE]):
         if issubclass(output, (ObjectVar, Base)):
             return ToObjectOperation.create(self, var_type or dict)
 
-        if dataclasses.is_dataclass(output):
-            return ToObjectOperation.create(self, var_type or dict)
-
         if issubclass(output, FunctionVar):
             # if fixed_type is not None and not issubclass(fixed_type, Callable):
             #     raise TypeError(
@@ -454,11 +447,11 @@ class Var(Generic[VAR_TYPE]):
 
         return self
 
-    def guess_type(self) -> Var:
+    def guess_type(self) -> ImmutableVar:
         """Guesses the type of the variable based on its `_var_type` attribute.
 
         Returns:
-            Var: The guessed type of the variable.
+            ImmutableVar: The guessed type of the variable.
 
         Raises:
             TypeError: If the type is not supported for guessing.
@@ -486,11 +479,7 @@ class Var(Generic[VAR_TYPE]):
             ):
                 return self.to(NumberVar, self._var_type)
 
-            if all(
-                inspect.isclass(t)
-                and (issubclass(t, Base) or dataclasses.is_dataclass(t))
-                for t in inner_types
-            ):
+            if all(inspect.isclass(t) and issubclass(t, Base) for t in inner_types):
                 return self.to(ObjectVar, self._var_type)
 
             return self
@@ -510,8 +499,6 @@ class Var(Generic[VAR_TYPE]):
             return self.to(StringVar, self._var_type)
         if issubclass(fixed_type, Base):
             return self.to(ObjectVar, self._var_type)
-        if dataclasses.is_dataclass(fixed_type):
-            return self.to(ObjectVar, self._var_type)
         return self
 
     def get_default_value(self) -> Any:
@@ -566,7 +553,7 @@ class Var(Generic[VAR_TYPE]):
         Returns:
             The name of the setter function.
         """
-        var_name_parts = self._js_expr.split(".")
+        var_name_parts = self._var_name.split(".")
         setter = constants.SETTER_PREFIX + var_name_parts[-1]
         var_data = self._get_all_var_data()
         if var_data is None:
@@ -581,7 +568,7 @@ class Var(Generic[VAR_TYPE]):
         Returns:
             A function that that creates a setter for the var.
         """
-        actual_name = self._js_expr.split(".")[-1]
+        actual_name = self._var_name.split(".")[-1]
 
         def setter(state: BaseState, value: Any):
             """Get the setter for the var.
@@ -596,7 +583,7 @@ class Var(Generic[VAR_TYPE]):
                     setattr(state, actual_name, value)
                 except ValueError:
                     console.debug(
-                        f"{type(state).__name__}.{self._js_expr}: Failed conversion of {value} to '{self._var_type.__name__}'. Value not set.",
+                        f"{type(state).__name__}.{self._var_name}: Failed conversion of {value} to '{self._var_type.__name__}'. Value not set.",
                     )
             else:
                 setattr(state, actual_name, value)
@@ -626,11 +613,11 @@ class Var(Generic[VAR_TYPE]):
             _var_data=VarData.merge(VarData.from_state(state), self._var_data),
         ).guess_type()
 
-    def __eq__(self, other: Var | Any) -> BooleanVar:
+    def __eq__(self, other: ImmutableVar | Any) -> BooleanVar:
         """Check if the current variable is equal to the given variable.
 
         Args:
-            other (Var | Any): The variable to compare with.
+            other (ImmutableVar | Any): The variable to compare with.
 
         Returns:
             BooleanVar: A BooleanVar object representing the result of the equality check.
@@ -639,11 +626,11 @@ class Var(Generic[VAR_TYPE]):
 
         return equal_operation(self, other)
 
-    def __ne__(self, other: Var | Any) -> BooleanVar:
+    def __ne__(self, other: ImmutableVar | Any) -> BooleanVar:
         """Check if the current object is not equal to the given object.
 
         Parameters:
-            other (Var | Any): The object to compare with.
+            other (ImmutableVar | Any): The object to compare with.
 
         Returns:
             BooleanVar: A BooleanVar object representing the result of the comparison.
@@ -662,7 +649,7 @@ class Var(Generic[VAR_TYPE]):
 
         return boolify(self)
 
-    def __and__(self, other: Var | Any) -> Var:
+    def __and__(self, other: ImmutableVar | Any) -> ImmutableVar:
         """Perform a logical AND operation on the current instance and another variable.
 
         Args:
@@ -673,7 +660,7 @@ class Var(Generic[VAR_TYPE]):
         """
         return and_operation(self, other)
 
-    def __rand__(self, other: Var | Any) -> Var:
+    def __rand__(self, other: ImmutableVar | Any) -> ImmutableVar:
         """Perform a logical AND operation on the current instance and another variable.
 
         Args:
@@ -684,7 +671,7 @@ class Var(Generic[VAR_TYPE]):
         """
         return and_operation(other, self)
 
-    def __or__(self, other: Var | Any) -> Var:
+    def __or__(self, other: ImmutableVar | Any) -> ImmutableVar:
         """Perform a logical OR operation on the current instance and another variable.
 
         Args:
@@ -695,7 +682,7 @@ class Var(Generic[VAR_TYPE]):
         """
         return or_operation(self, other)
 
-    def __ror__(self, other: Var | Any) -> Var:
+    def __ror__(self, other: ImmutableVar | Any) -> ImmutableVar:
         """Perform a logical OR operation on the current instance and another variable.
 
         Args:
@@ -725,7 +712,7 @@ class Var(Generic[VAR_TYPE]):
 
         return JSON_STRINGIFY.call(self).to(StringVar)
 
-    def as_ref(self) -> Var:
+    def as_ref(self) -> ImmutableVar:
         """Get a reference to the var.
 
         Returns:
@@ -733,14 +720,14 @@ class Var(Generic[VAR_TYPE]):
         """
         from .object import ObjectVar
 
-        refs = Var(
-            _js_expr="refs",
+        refs = ImmutableVar(
+            _var_name="refs",
             _var_data=VarData(
                 imports={
                     f"/{constants.Dirs.STATE_PATH}": [imports.ImportVar(tag="refs")]
                 }
             ),
-        ).to(ObjectVar, Dict[str, str])
+        ).to(ObjectVar)
         return refs[LiteralVar.create(str(self))]
 
     @deprecated("Use `.js_type()` instead.")
@@ -826,8 +813,7 @@ class Var(Generic[VAR_TYPE]):
             TypeError: If the var type is Any.
         """
         if name.startswith("_"):
-            return self.__getattribute__(name)
-
+            return super(ImmutableVar, self).__getattribute__(name)
         if self._var_type is Any:
             raise TypeError(
                 f"You must provide an annotation for the state var `{str(self)}`. Annotation cannot be `{self._var_type}`."
@@ -871,85 +857,26 @@ class Var(Generic[VAR_TYPE]):
         var_data = self._get_all_var_data()
         return var_data.state if var_data else ""
 
-    @overload
-    @classmethod
-    def range(cls, stop: int | NumberVar, /) -> ArrayVar[List[int]]: ...
-
-    @overload
-    @classmethod
-    def range(
-        cls,
-        start: int | NumberVar,
-        end: int | NumberVar,
-        step: int | NumberVar = 1,
-        /,
-    ) -> ArrayVar[List[int]]: ...
-
-    @classmethod
-    def range(
-        cls,
-        first_endpoint: int | NumberVar,
-        second_endpoint: int | NumberVar | None = None,
-        step: int | NumberVar | None = None,
-    ) -> ArrayVar[List[int]]:
-        """Create a range of numbers.
 
-        Args:
-            first_endpoint: The end of the range if second_endpoint is not provided, otherwise the start of the range.
-            second_endpoint: The end of the range.
-            step: The step of the range.
+OUTPUT = TypeVar("OUTPUT", bound=ImmutableVar)
 
-        Returns:
-            The range of numbers.
-        """
-        from .sequence import ArrayVar
 
-        return ArrayVar.range(first_endpoint, second_endpoint, step)
+def _encode_var(value: ImmutableVar) -> str:
+    """Encode the state name into a formatted var.
 
-    def __bool__(self) -> bool:
-        """Raise exception if using Var in a boolean context.
-
-        Raises:
-            VarTypeError: when attempting to bool-ify the Var.
-        """
-        raise VarTypeError(
-            f"Cannot convert Var {str(self)!r} to bool for use with `if`, `and`, `or`, and `not`. "
-            "Instead use `rx.cond` and bitwise operators `&` (and), `|` (or), `~` (invert)."
-        )
-
-    def __iter__(self) -> Any:
-        """Raise exception if using Var in an iterable context.
-
-        Raises:
-            VarTypeError: when attempting to iterate over the Var.
-        """
-        raise VarTypeError(
-            f"Cannot iterate over Var {str(self)!r}. Instead use `rx.foreach`."
-        )
-
-    def __contains__(self, _: Any) -> Var:
-        """Override the 'in' operator to alert the user that it is not supported.
-
-        Raises:
-            VarTypeError: the operation is not supported
-        """
-        raise VarTypeError(
-            "'in' operator not supported for Var types, use Var.contains() instead."
-        )
-
-    def json(self) -> str:
-        """Serialize the var to a JSON string.
+    Args:
+        value: The value to encode the state name into.
 
-        Raises:
-            NotImplementedError: If the method is not implemented.
-        """
-        raise NotImplementedError("Var subclasses must implement the json method.")
+    Returns:
+        The encoded var.
+    """
+    return f"{value}"
 
 
-OUTPUT = TypeVar("OUTPUT", bound=Var)
+serializers.serializer(_encode_var)
 
 
-class LiteralVar(Var):
+class LiteralVar(ImmutableVar):
     """Base class for immutable literal vars."""
 
     @classmethod
@@ -957,7 +884,7 @@ class LiteralVar(Var):
         cls,
         value: Any,
         _var_data: VarData | None = None,
-    ) -> Var:
+    ) -> ImmutableVar:
         """Create a var from a value.
 
         Args:
@@ -974,7 +901,7 @@ class LiteralVar(Var):
         from .object import LiteralObjectVar
         from .sequence import LiteralArrayVar, LiteralStringVar
 
-        if isinstance(value, Var):
+        if isinstance(value, ImmutableVar):
             if _var_data is None:
                 return value
             return value._replace(merge_var_data=_var_data)
@@ -997,7 +924,7 @@ class LiteralVar(Var):
         if value is None:
             return LiteralNoneVar.create(_var_data=_var_data)
 
-        from reflex.event import EventChain, EventHandler, EventSpec
+        from reflex.event import EventChain, EventSpec
         from reflex.utils.format import get_event_handler_parts
 
         from .function import ArgsFunctionOperation, FunctionStringVar
@@ -1021,12 +948,14 @@ class LiteralVar(Var):
             sig = inspect.signature(value.args_spec)  # type: ignore
             if sig.parameters:
                 arg_def = tuple((f"_{p}" for p in sig.parameters))
-                arg_def_expr = LiteralVar.create([Var(_js_expr=arg) for arg in arg_def])
+                arg_def_expr = LiteralVar.create(
+                    [ImmutableVar.create_safe(arg) for arg in arg_def]
+                )
             else:
                 # add a default argument for addEvents if none were specified in value.args_spec
                 # used to trigger the preventDefault() on the event.
                 arg_def = ("...args",)
-                arg_def_expr = Var(_js_expr="args")
+                arg_def_expr = ImmutableVar.create_safe("args")
 
             return ArgsFunctionOperation.create(
                 arg_def,
@@ -1039,8 +968,12 @@ class LiteralVar(Var):
                 ),
             )
 
-        if isinstance(value, EventHandler):
-            return Var(_js_expr=".".join(filter(None, get_event_handler_parts(value))))
+        if isinstance(value, Base):
+            return LiteralObjectVar.create(
+                {k: (None if callable(v) else v) for k, v in value.dict().items()},
+                _var_type=type(value),
+                _var_data=_var_data,
+            )
 
         serialized_value = serializers.serialize(value)
         if serialized_value is not None:
@@ -1050,37 +983,8 @@ class LiteralVar(Var):
                     _var_type=type(value),
                     _var_data=_var_data,
                 )
-            if isinstance(serialized_value, str):
-                return LiteralStringVar.create(
-                    serialized_value, _var_type=type(value), _var_data=_var_data
-                )
             return LiteralVar.create(serialized_value, _var_data=_var_data)
 
-        if isinstance(value, Base):
-            # get the fields of the pydantic class
-            fields = value.__fields__.keys()
-            one_level_dict = {field: getattr(value, field) for field in fields}
-
-            return LiteralObjectVar.create(
-                {
-                    field: value
-                    for field, value in one_level_dict.items()
-                    if not callable(value)
-                },
-                _var_type=type(value),
-                _var_data=_var_data,
-            )
-
-        if dataclasses.is_dataclass(value) and not isinstance(value, type):
-            return LiteralObjectVar.create(
-                {
-                    k: (None if callable(v) else v)
-                    for k, v in dataclasses.asdict(value).items()
-                },
-                _var_type=type(value),
-                _var_data=_var_data,
-            )
-
         raise TypeError(
             f"Unsupported type {type(value)} for LiteralVar. Tried to create a LiteralVar from {value}."
         )
@@ -1099,19 +1003,6 @@ class LiteralVar(Var):
         )
 
 
-@serializers.serializer
-def serialize_literal(value: LiteralVar):
-    """Serialize a Literal type.
-
-    Args:
-        value: The Literal to serialize.
-
-    Returns:
-        The serialized Literal.
-    """
-    return serializers.serialize(value._var_value)
-
-
 P = ParamSpec("P")
 T = TypeVar("T")
 
@@ -1120,7 +1011,7 @@ T = TypeVar("T")
 @overload
 def var_operation(
     func: Callable[P, CustomVarOperationReturn[NoReturn]],
-) -> Callable[P, Var]: ...
+) -> Callable[P, ImmutableVar]: ...
 
 
 @overload
@@ -1164,7 +1055,7 @@ def var_operation(
 
 def var_operation(
     func: Callable[P, CustomVarOperationReturn[T]],
-) -> Callable[P, Var[T]]:
+) -> Callable[P, ImmutableVar[T]]:
     """Decorator for creating a var operation.
 
     Example:
@@ -1182,14 +1073,18 @@ def var_operation(
     """
 
     @functools.wraps(func)
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> Var[T]:
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> ImmutableVar[T]:
         func_args = list(inspect.signature(func).parameters)
         args_vars = {
-            func_args[i]: (LiteralVar.create(arg) if not isinstance(arg, Var) else arg)
+            func_args[i]: (
+                LiteralVar.create(arg) if not isinstance(arg, ImmutableVar) else arg
+            )
             for i, arg in enumerate(args)
         }
         kwargs_vars = {
-            key: LiteralVar.create(value) if not isinstance(value, Var) else value
+            key: LiteralVar.create(value)
+            if not isinstance(value, ImmutableVar)
+            else value
             for key, value in kwargs.items()
         }
 
@@ -1212,13 +1107,10 @@ def unionize(*args: Type) -> Type:
     """
     if not args:
         return Any
-    if len(args) == 1:
-        return args[0]
-    # We are bisecting the args list here to avoid hitting the recursion limit
-    # In Python versions >= 3.11, we can simply do `return Union[*args]`
-    midpoint = len(args) // 2
-    first_half, second_half = args[:midpoint], args[midpoint:]
-    return Union[unionize(*first_half), unionize(*second_half)]
+    first, *rest = args
+    if not rest:
+        return first
+    return Union[first, unionize(*rest)]
 
 
 def figure_out_type(value: Any) -> types.GenericType:
@@ -1241,7 +1133,7 @@ def figure_out_type(value: Any) -> types.GenericType:
             unionize(*(figure_out_type(k) for k in value)),
             unionize(*(figure_out_type(v) for v in value.values())),
         ]
-    if isinstance(value, Var):
+    if isinstance(value, ImmutableVar):
         return value._var_type
     return type(value)
 
@@ -1264,7 +1156,7 @@ class CachedVarOperation:
 
     def __post_init__(self):
         """Post-initialize the CachedVarOperation."""
-        object.__delattr__(self, "_js_expr")
+        object.__delattr__(self, "_var_name")
 
     def __getattr__(self, name: str) -> Any:
         """Get an attribute of the var.
@@ -1275,7 +1167,7 @@ class CachedVarOperation:
         Returns:
             The attribute.
         """
-        if name == "_js_expr":
+        if name == "_var_name":
             return self._cached_var_name
 
         parent_classes = inspect.getmro(self.__class__)
@@ -1302,7 +1194,9 @@ class CachedVarOperation:
         return VarData.merge(
             *map(
                 lambda value: (
-                    value._get_all_var_data() if isinstance(value, Var) else None
+                    value._get_all_var_data()
+                    if isinstance(value, ImmutableVar)
+                    else None
                 ),
                 map(
                     lambda field: getattr(self, field.name),
@@ -1324,13 +1218,13 @@ class CachedVarOperation:
                 *[
                     getattr(self, field.name)
                     for field in dataclasses.fields(self)  # type: ignore
-                    if field.name not in ["_js_expr", "_var_data", "_var_type"]
+                    if field.name not in ["_var_name", "_var_data", "_var_type"]
                 ],
             )
         )
 
 
-def and_operation(a: Var | Any, b: Var | Any) -> Var:
+def and_operation(a: ImmutableVar | Any, b: ImmutableVar | Any) -> ImmutableVar:
     """Perform a logical AND operation on two variables.
 
     Args:
@@ -1344,7 +1238,7 @@ def and_operation(a: Var | Any, b: Var | Any) -> Var:
 
 
 @var_operation
-def _and_operation(a: Var, b: Var):
+def _and_operation(a: ImmutableVar, b: ImmutableVar):
     """Perform a logical AND operation on two variables.
 
     Args:
@@ -1360,7 +1254,7 @@ def _and_operation(a: Var, b: Var):
     )
 
 
-def or_operation(a: Var | Any, b: Var | Any) -> Var:
+def or_operation(a: ImmutableVar | Any, b: ImmutableVar | Any) -> ImmutableVar:
     """Perform a logical OR operation on two variables.
 
     Args:
@@ -1374,7 +1268,7 @@ def or_operation(a: Var | Any, b: Var | Any) -> Var:
 
 
 @var_operation
-def _or_operation(a: Var, b: Var):
+def _or_operation(a: ImmutableVar, b: ImmutableVar):
     """Perform a logical OR operation on two variables.
 
     Args:
@@ -1395,36 +1289,36 @@ def _or_operation(a: Var, b: Var):
     frozen=True,
     **{"slots": True} if sys.version_info >= (3, 10) else {},
 )
-class CallableVar(Var):
+class ImmutableCallableVar(ImmutableVar):
     """Decorate a Var-returning function to act as both a Var and a function.
 
     This is used as a compatibility shim for replacing Var objects in the
     API with functions that return a family of Var.
     """
 
-    fn: Callable[..., Var] = dataclasses.field(
-        default_factory=lambda: lambda: Var(_js_expr="undefined")
+    fn: Callable[..., ImmutableVar] = dataclasses.field(
+        default_factory=lambda: lambda: ImmutableVar(_var_name="undefined")
     )
-    original_var: Var = dataclasses.field(
-        default_factory=lambda: Var(_js_expr="undefined")
+    original_var: ImmutableVar = dataclasses.field(
+        default_factory=lambda: ImmutableVar(_var_name="undefined")
     )
 
-    def __init__(self, fn: Callable[..., Var]):
+    def __init__(self, fn: Callable[..., ImmutableVar]):
         """Initialize a CallableVar.
 
         Args:
             fn: The function to decorate (must return Var)
         """
         original_var = fn()
-        super(CallableVar, self).__init__(
-            _js_expr=original_var._js_expr,
+        super(ImmutableCallableVar, self).__init__(
+            _var_name=original_var._var_name,
             _var_type=original_var._var_type,
             _var_data=VarData.merge(original_var._get_all_var_data()),
         )
         object.__setattr__(self, "fn", fn)
         object.__setattr__(self, "original_var", original_var)
 
-    def __call__(self, *args, **kwargs) -> Var:
+    def __call__(self, *args, **kwargs) -> ImmutableVar:
         """Call the decorated function.
 
         Args:
@@ -1453,13 +1347,13 @@ DICT_VAL = TypeVar("DICT_VAL")
 LIST_INSIDE = TypeVar("LIST_INSIDE")
 
 
-class FakeComputedVarBaseClass(property):
+class FakeComputedVarBaseClass(Var, property):
     """A fake base class for ComputedVar to avoid inheriting from property."""
 
     __pydantic_run_validation__ = False
 
 
-def is_computed_var(obj: Any) -> TypeGuard[ComputedVar]:
+def is_computed_var(obj: Any) -> TypeGuard[ImmutableComputedVar]:
     """Check if the object is a ComputedVar.
 
     Args:
@@ -1476,7 +1370,7 @@ def is_computed_var(obj: Any) -> TypeGuard[ComputedVar]:
     frozen=True,
     **{"slots": True} if sys.version_info >= (3, 10) else {},
 )
-class ComputedVar(Var[RETURN_TYPE]):
+class ImmutableComputedVar(ImmutableVar[RETURN_TYPE]):
     """A field with computed getters."""
 
     # Whether to track dependencies and cache computed values
@@ -1506,7 +1400,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         fget: Callable[[BASE_STATE], RETURN_TYPE],
         initial_value: RETURN_TYPE | types.Unset = types.Unset(),
         cache: bool = False,
-        deps: Optional[List[Union[str, Var]]] = None,
+        deps: Optional[List[Union[str, ImmutableVar]]] = None,
         auto_deps: bool = True,
         interval: Optional[Union[int, datetime.timedelta]] = None,
         backend: bool | None = None,
@@ -1530,12 +1424,12 @@ class ComputedVar(Var[RETURN_TYPE]):
         hints = get_type_hints(fget)
         hint = hints.get("return", Any)
 
-        kwargs["_js_expr"] = kwargs.pop("_js_expr", fget.__name__)
+        kwargs["_var_name"] = kwargs.pop("_var_name", fget.__name__)
         kwargs["_var_type"] = kwargs.pop("_var_type", hint)
 
-        Var.__init__(
+        ImmutableVar.__init__(
             self,
-            _js_expr=kwargs.pop("_js_expr"),
+            _var_name=kwargs.pop("_var_name"),
             _var_type=kwargs.pop("_var_type"),
             _var_data=kwargs.pop("_var_data", None),
         )
@@ -1556,7 +1450,7 @@ class ComputedVar(Var[RETURN_TYPE]):
             deps = []
         else:
             for dep in deps:
-                if isinstance(dep, Var):
+                if isinstance(dep, ImmutableVar):
                     continue
                 if isinstance(dep, str) and dep != "":
                     continue
@@ -1566,7 +1460,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         object.__setattr__(
             self,
             "_static_deps",
-            {dep._js_expr if isinstance(dep, Var) else dep for dep in deps},
+            {dep._var_name if isinstance(dep, ImmutableVar) else dep for dep in deps},
         )
         object.__setattr__(self, "_auto_deps", auto_deps)
 
@@ -1594,7 +1488,7 @@ class ComputedVar(Var[RETURN_TYPE]):
             auto_deps=kwargs.pop("auto_deps", self._auto_deps),
             interval=kwargs.pop("interval", self._update_interval),
             backend=kwargs.pop("backend", self._backend),
-            _js_expr=kwargs.pop("_js_expr", self._js_expr),
+            _var_name=kwargs.pop("_var_name", self._var_name),
             _var_type=kwargs.pop("_var_type", self._var_type),
             _var_data=kwargs.pop(
                 "_var_data", VarData.merge(self._var_data, merge_var_data)
@@ -1614,7 +1508,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         Returns:
             An attribute name.
         """
-        return f"__cached_{self._js_expr}"
+        return f"__cached_{self._var_name}"
 
     @property
     def _last_updated_attr(self) -> str:
@@ -1623,7 +1517,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         Returns:
             An attribute name.
         """
-        return f"__last_updated_{self._js_expr}"
+        return f"__last_updated_{self._var_name}"
 
     def needs_update(self, instance: BaseState) -> bool:
         """Check if the computed var needs to be updated.
@@ -1643,48 +1537,50 @@ class ComputedVar(Var[RETURN_TYPE]):
 
     @overload
     def __get__(
-        self: ComputedVar[int] | ComputedVar[float],
+        self: ImmutableComputedVar[int] | ImmutableComputedVar[float],
         instance: None,
         owner: Type,
     ) -> NumberVar: ...
 
     @overload
     def __get__(
-        self: ComputedVar[str],
+        self: ImmutableComputedVar[str],
         instance: None,
         owner: Type,
     ) -> StringVar: ...
 
     @overload
     def __get__(
-        self: ComputedVar[dict[DICT_KEY, DICT_VAL]],
+        self: ImmutableComputedVar[dict[DICT_KEY, DICT_VAL]],
         instance: None,
         owner: Type,
     ) -> ObjectVar[dict[DICT_KEY, DICT_VAL]]: ...
 
     @overload
     def __get__(
-        self: ComputedVar[list[LIST_INSIDE]],
+        self: ImmutableComputedVar[list[LIST_INSIDE]],
         instance: None,
         owner: Type,
     ) -> ArrayVar[list[LIST_INSIDE]]: ...
 
     @overload
     def __get__(
-        self: ComputedVar[set[LIST_INSIDE]],
+        self: ImmutableComputedVar[set[LIST_INSIDE]],
         instance: None,
         owner: Type,
     ) -> ArrayVar[set[LIST_INSIDE]]: ...
 
     @overload
     def __get__(
-        self: ComputedVar[tuple[LIST_INSIDE, ...]],
+        self: ImmutableComputedVar[tuple[LIST_INSIDE, ...]],
         instance: None,
         owner: Type,
     ) -> ArrayVar[tuple[LIST_INSIDE, ...]]: ...
 
     @overload
-    def __get__(self, instance: None, owner: Type) -> ComputedVar[RETURN_TYPE]: ...
+    def __get__(
+        self, instance: None, owner: Type
+    ) -> ImmutableComputedVar[RETURN_TYPE]: ...
 
     @overload
     def __get__(self, instance: BaseState, owner: Type) -> RETURN_TYPE: ...
@@ -1703,13 +1599,13 @@ class ComputedVar(Var[RETURN_TYPE]):
         """
         if instance is None:
             state_where_defined = owner
-            while self._js_expr in state_where_defined.inherited_vars:
+            while self.fget.__name__ in state_where_defined.inherited_vars:
                 state_where_defined = state_where_defined.get_parent_state()
 
             return self._replace(
-                _js_expr=format_state_name(state_where_defined.get_full_name())
+                _var_name=format_state_name(state_where_defined.get_full_name())
                 + "."
-                + self._js_expr,
+                + self._var_name,
                 merge_var_data=VarData.from_state(state_where_defined),
             ).guess_type()
 
@@ -1809,7 +1705,7 @@ class ComputedVar(Var[RETURN_TYPE]):
                     )
                 # recurse into property fget functions
                 elif isinstance(ref_obj, property) and not isinstance(
-                    ref_obj, ComputedVar
+                    ref_obj, ImmutableComputedVar
                 ):
                     d.update(
                         self._deps(
@@ -1877,7 +1773,7 @@ class ComputedVar(Var[RETURN_TYPE]):
         return self._fget
 
 
-class DynamicRouteVar(ComputedVar[Union[str, List[str]]]):
+class DynamicRouteVar(ImmutableComputedVar[Union[str, List[str]]]):
     """A ComputedVar that represents a dynamic route."""
 
     pass
@@ -1888,41 +1784,45 @@ if TYPE_CHECKING:
 
 
 @overload
-def computed_var(
+def immutable_computed_var(
     fget: None = None,
     initial_value: Any | types.Unset = types.Unset(),
     cache: bool = False,
-    deps: Optional[List[Union[str, Var]]] = None,
+    deps: Optional[List[Union[str, ImmutableVar]]] = None,
     auto_deps: bool = True,
     interval: Optional[Union[datetime.timedelta, int]] = None,
     backend: bool | None = None,
     **kwargs,
-) -> Callable[[Callable[[BASE_STATE], RETURN_TYPE]], ComputedVar[RETURN_TYPE]]: ...
+) -> Callable[
+    [Callable[[BASE_STATE], RETURN_TYPE]], ImmutableComputedVar[RETURN_TYPE]
+]: ...
 
 
 @overload
-def computed_var(
+def immutable_computed_var(
     fget: Callable[[BASE_STATE], RETURN_TYPE],
     initial_value: RETURN_TYPE | types.Unset = types.Unset(),
     cache: bool = False,
-    deps: Optional[List[Union[str, Var]]] = None,
+    deps: Optional[List[Union[str, ImmutableVar]]] = None,
     auto_deps: bool = True,
     interval: Optional[Union[datetime.timedelta, int]] = None,
     backend: bool | None = None,
     **kwargs,
-) -> ComputedVar[RETURN_TYPE]: ...
+) -> ImmutableComputedVar[RETURN_TYPE]: ...
 
 
-def computed_var(
+def immutable_computed_var(
     fget: Callable[[BASE_STATE], Any] | None = None,
     initial_value: Any | types.Unset = types.Unset(),
     cache: bool = False,
-    deps: Optional[List[Union[str, Var]]] = None,
+    deps: Optional[List[Union[str, ImmutableVar]]] = None,
     auto_deps: bool = True,
     interval: Optional[Union[datetime.timedelta, int]] = None,
     backend: bool | None = None,
     **kwargs,
-) -> ComputedVar | Callable[[Callable[[BASE_STATE], Any]], ComputedVar]:
+) -> (
+    ImmutableComputedVar | Callable[[Callable[[BASE_STATE], Any]], ImmutableComputedVar]
+):
     """A ComputedVar decorator with or without kwargs.
 
     Args:
@@ -1949,10 +1849,10 @@ def computed_var(
         raise VarDependencyError("Cannot track dependencies without caching.")
 
     if fget is not None:
-        return ComputedVar(fget, cache=cache)
+        return ImmutableComputedVar(fget, cache=cache)
 
-    def wrapper(fget: Callable[[BASE_STATE], Any]) -> ComputedVar:
-        return ComputedVar(
+    def wrapper(fget: Callable[[BASE_STATE], Any]) -> ImmutableComputedVar:
+        return ImmutableComputedVar(
             fget,
             initial_value=initial_value,
             cache=cache,
@@ -1969,7 +1869,7 @@ def computed_var(
 RETURN = TypeVar("RETURN")
 
 
-class CustomVarOperationReturn(Var[RETURN]):
+class CustomVarOperationReturn(ImmutableVar[RETURN]):
     """Base class for custom var operations."""
 
     @classmethod
@@ -1990,7 +1890,7 @@ class CustomVarOperationReturn(Var[RETURN]):
             The CustomVarOperation.
         """
         return CustomVarOperationReturn(
-            _js_expr=js_expression,
+            _var_name=js_expression,
             _var_type=_var_type or Any,
             _var_data=_var_data,
         )
@@ -1999,23 +1899,17 @@ class CustomVarOperationReturn(Var[RETURN]):
 def var_operation_return(
     js_expression: str,
     var_type: Type[RETURN] | None = None,
-    var_data: VarData | None = None,
 ) -> CustomVarOperationReturn[RETURN]:
     """Shortcut for creating a CustomVarOperationReturn.
 
     Args:
         js_expression: The JavaScript expression to evaluate.
         var_type: The type of the var.
-        var_data: Additional hooks and imports associated with the Var.
 
     Returns:
         The CustomVarOperationReturn.
     """
-    return CustomVarOperationReturn.create(
-        js_expression,
-        var_type,
-        var_data,
-    )
+    return CustomVarOperationReturn.create(js_expression, var_type)
 
 
 @dataclasses.dataclass(
@@ -2023,10 +1917,12 @@ def var_operation_return(
     frozen=True,
     **{"slots": True} if sys.version_info >= (3, 10) else {},
 )
-class CustomVarOperation(CachedVarOperation, Var[T]):
+class CustomVarOperation(CachedVarOperation, ImmutableVar[T]):
     """Base class for custom var operations."""
 
-    _args: Tuple[Tuple[str, Var], ...] = dataclasses.field(default_factory=tuple)
+    _args: Tuple[Tuple[str, ImmutableVar], ...] = dataclasses.field(
+        default_factory=tuple
+    )
 
     _return: CustomVarOperationReturn[T] = dataclasses.field(
         default_factory=lambda: CustomVarOperationReturn.create("")
@@ -2060,7 +1956,7 @@ class CustomVarOperation(CachedVarOperation, Var[T]):
     @classmethod
     def create(
         cls,
-        args: Tuple[Tuple[str, Var], ...],
+        args: Tuple[Tuple[str, ImmutableVar], ...],
         return_var: CustomVarOperationReturn[T],
         _var_data: VarData | None = None,
     ) -> CustomVarOperation[T]:
@@ -2075,7 +1971,7 @@ class CustomVarOperation(CachedVarOperation, Var[T]):
             The CustomVarOperation.
         """
         return CustomVarOperation(
-            _js_expr="",
+            _var_name="",
             _var_type=return_var._var_type,
             _var_data=_var_data,
             _args=args,
@@ -2083,7 +1979,7 @@ class CustomVarOperation(CachedVarOperation, Var[T]):
         )
 
 
-class NoneVar(Var[None]):
+class NoneVar(ImmutableVar[None]):
     """A var representing None."""
 
 
@@ -2112,7 +2008,7 @@ class LiteralNoneVar(LiteralVar, NoneVar):
             The var.
         """
         return LiteralNoneVar(
-            _js_expr="null",
+            _var_name="null",
             _var_type=None,
             _var_data=_var_data,
         )
@@ -2155,7 +2051,7 @@ class ToNoneOperation(CachedVarOperation, NoneVar):
             The ToNoneOperation.
         """
         return ToNoneOperation(
-            _js_expr="",
+            _var_name="",
             _var_type=None,
             _var_data=_var_data,
             _original_var=var,
@@ -2167,7 +2063,7 @@ class ToNoneOperation(CachedVarOperation, NoneVar):
     frozen=True,
     **{"slots": True} if sys.version_info >= (3, 10) else {},
 )
-class StateOperation(CachedVarOperation, Var):
+class StateOperation(CachedVarOperation, ImmutableVar):
     """A var operation that accesses a field on an object."""
 
     _state_name: str = dataclasses.field(default="")
@@ -2191,7 +2087,7 @@ class StateOperation(CachedVarOperation, Var):
         Returns:
             The attribute.
         """
-        if name == "_js_expr":
+        if name == "_var_name":
             return self._cached_var_name
 
         return getattr(self._field, name)
@@ -2200,7 +2096,7 @@ class StateOperation(CachedVarOperation, Var):
     def create(
         cls,
         state_name: str,
-        field: Var,
+        field: ImmutableVar,
         _var_data: VarData | None = None,
     ) -> StateOperation:
         """Create a DotOperation.
@@ -2214,7 +2110,7 @@ class StateOperation(CachedVarOperation, Var):
             The DotOperation.
         """
         return StateOperation(
-            _js_expr="",
+            _var_name="",
             _var_type=field._var_type,
             _var_data=_var_data,
             _state_name=state_name,
@@ -2238,7 +2134,7 @@ class ToOperation:
 
     def __post_init__(self):
         """Post initialization."""
-        object.__delattr__(self, "_js_expr")
+        object.__delattr__(self, "_var_name")
 
     def __hash__(self) -> int:
         """Calculate the hash value of the object.
@@ -2277,287 +2173,8 @@ class ToOperation:
             The ToOperation.
         """
         return cls(
-            _js_expr="",  # type: ignore
+            _var_name="",  # type: ignore
             _var_data=_var_data,  # type: ignore
             _var_type=_var_type or cls._default_var_type,  # type: ignore
             _original=value,  # type: ignore
         )
-
-
-def get_uuid_string_var() -> Var:
-    """Return a Var that generates a single memoized UUID via .web/utils/state.js.
-
-    useMemo with an empty dependency array ensures that the generated UUID is
-    consistent across re-renders of the component.
-
-    Returns:
-        A Var that generates a UUID at runtime.
-    """
-    from reflex.utils.imports import ImportVar
-    from reflex.vars import Var
-
-    unique_uuid_var = get_unique_variable_name()
-    unique_uuid_var_data = VarData(
-        imports={
-            f"/{constants.Dirs.STATE_PATH}": {ImportVar(tag="generateUUID")},  # type: ignore
-            "react": "useMemo",
-        },
-        hooks={f"const {unique_uuid_var} = useMemo(generateUUID, [])": None},
-    )
-
-    return Var(
-        _js_expr=unique_uuid_var,
-        _var_type=str,
-        _var_data=unique_uuid_var_data,
-    )
-
-
-# Set of unique variable names.
-USED_VARIABLES = set()
-
-
-def get_unique_variable_name() -> str:
-    """Get a unique variable name.
-
-    Returns:
-        The unique variable name.
-    """
-    name = "".join([random.choice(string.ascii_lowercase) for _ in range(8)])
-    if name not in USED_VARIABLES:
-        USED_VARIABLES.add(name)
-        return name
-    return get_unique_variable_name()
-
-
-@dataclasses.dataclass(
-    eq=True,
-    frozen=True,
-)
-class VarData:
-    """Metadata associated with a x."""
-
-    # The name of the enclosing state.
-    state: str = dataclasses.field(default="")
-
-    # Imports needed to render this var
-    imports: ImmutableParsedImportDict = dataclasses.field(default_factory=tuple)
-
-    # Hooks that need to be present in the component to render this var
-    hooks: Tuple[str, ...] = dataclasses.field(default_factory=tuple)
-
-    def __init__(
-        self,
-        state: str = "",
-        imports: ImportDict | ParsedImportDict | None = None,
-        hooks: dict[str, None] | None = None,
-    ):
-        """Initialize the var data.
-
-        Args:
-            state: The name of the enclosing state.
-            imports: Imports needed to render this var.
-            hooks: Hooks that need to be present in the component to render this var.
-        """
-        immutable_imports: ImmutableParsedImportDict = tuple(
-            sorted(
-                ((k, tuple(sorted(v))) for k, v in parse_imports(imports or {}).items())
-            )
-        )
-        object.__setattr__(self, "state", state)
-        object.__setattr__(self, "imports", immutable_imports)
-        object.__setattr__(self, "hooks", tuple(hooks or {}))
-
-    def old_school_imports(self) -> ImportDict:
-        """Return the imports as a mutable dict.
-
-        Returns:
-            The imports as a mutable dict.
-        """
-        return dict((k, list(v)) for k, v in self.imports)
-
-    @classmethod
-    def merge(cls, *others: VarData | None) -> VarData | None:
-        """Merge multiple var data objects.
-
-        Args:
-            *others: The var data objects to merge.
-
-        Returns:
-            The merged var data object.
-        """
-        state = ""
-        _imports = {}
-        hooks = {}
-        for var_data in others:
-            if var_data is None:
-                continue
-            state = state or var_data.state
-            _imports = imports.merge_imports(_imports, var_data.imports)
-            hooks.update(
-                var_data.hooks
-                if isinstance(var_data.hooks, dict)
-                else {k: None for k in var_data.hooks}
-            )
-
-        if state or _imports or hooks:
-            return VarData(
-                state=state,
-                imports=_imports,
-                hooks=hooks,
-            )
-        return None
-
-    def __bool__(self) -> bool:
-        """Check if the var data is non-empty.
-
-        Returns:
-            True if any field is set to a non-default value.
-        """
-        return bool(self.state or self.imports or self.hooks)
-
-    def __eq__(self, other: Any) -> bool:
-        """Check if two var data objects are equal.
-
-        Args:
-            other: The other var data object to compare.
-
-        Returns:
-            True if all fields are equal and collapsed imports are equal.
-        """
-        if not isinstance(other, VarData):
-            return False
-
-        # Don't compare interpolations - that's added in by the decoder, and
-        # not part of the vardata itself.
-        return (
-            self.state == other.state
-            and self.hooks
-            == (
-                other.hooks if isinstance(other, VarData) else tuple(other.hooks.keys())
-            )
-            and imports.collapse_imports(self.imports)
-            == imports.collapse_imports(other.imports)
-        )
-
-    @classmethod
-    def from_state(cls, state: Type[BaseState] | str) -> VarData:
-        """Set the state of the var.
-
-        Args:
-            state: The state to set or the full name of the state.
-
-        Returns:
-            The var with the set state.
-        """
-        from reflex.utils import format
-
-        state_name = state if isinstance(state, str) else state.get_full_name()
-        new_var_data = VarData(
-            state=state_name,
-            hooks={
-                "const {0} = useContext(StateContexts.{0})".format(
-                    format.format_state_name(state_name)
-                ): None
-            },
-            imports={
-                f"/{constants.Dirs.CONTEXTS_PATH}": [ImportVar(tag="StateContexts")],
-                "react": [ImportVar(tag="useContext")],
-            },
-        )
-        return new_var_data
-
-
-def _decode_var_immutable(value: str) -> tuple[VarData | None, str]:
-    """Decode the state name from a formatted var.
-
-    Args:
-        value: The value to extract the state name from.
-
-    Returns:
-        The extracted state name and the value without the state name.
-    """
-    var_datas = []
-    if isinstance(value, str):
-        # fast path if there is no encoded VarData
-        if constants.REFLEX_VAR_OPENING_TAG not in value:
-            return None, value
-
-        offset = 0
-
-        # Find all tags.
-        while m := _decode_var_pattern.search(value):
-            start, end = m.span()
-            value = value[:start] + value[end:]
-
-            serialized_data = m.group(1)
-
-            if serialized_data.isnumeric() or (
-                serialized_data[0] == "-" and serialized_data[1:].isnumeric()
-            ):
-                # This is a global immutable var.
-                var = _global_vars[int(serialized_data)]
-                var_data = var._get_all_var_data()
-
-                if var_data is not None:
-                    var_datas.append(var_data)
-            offset += end - start
-
-    return VarData.merge(*var_datas) if var_datas else None, value
-
-
-# Compile regex for finding reflex var tags.
-_decode_var_pattern_re = (
-    rf"{constants.REFLEX_VAR_OPENING_TAG}(.*?){constants.REFLEX_VAR_CLOSING_TAG}"
-)
-_decode_var_pattern = re.compile(_decode_var_pattern_re, flags=re.DOTALL)
-
-# Defined global immutable vars.
-_global_vars: Dict[int, Var] = {}
-
-
-def _extract_var_data(value: Iterable) -> list[VarData | None]:
-    """Extract the var imports and hooks from an iterable containing a Var.
-
-    Args:
-        value: The iterable to extract the VarData from
-
-    Returns:
-        The extracted VarDatas.
-    """
-    from reflex.style import Style
-    from reflex.vars import Var
-
-    var_datas = []
-    with contextlib.suppress(TypeError):
-        for sub in value:
-            if isinstance(sub, Var):
-                var_datas.append(sub._var_data)
-            elif not isinstance(sub, str):
-                # Recurse into dict values.
-                if hasattr(sub, "values") and callable(sub.values):
-                    var_datas.extend(_extract_var_data(sub.values()))
-                # Recurse into iterable values (or dict keys).
-                var_datas.extend(_extract_var_data(sub))
-
-    # Style objects should already have _var_data.
-    if isinstance(value, Style):
-        var_datas.append(value._var_data)
-    else:
-        # Recurse when value is a dict itself.
-        values = getattr(value, "values", None)
-        if callable(values):
-            var_datas.extend(_extract_var_data(values()))
-    return var_datas
-
-
-# These names were changed in reflex 0.3.0
-REPLACED_NAMES = {
-    "full_name": "_var_full_name",
-    "name": "_js_expr",
-    "state": "_var_data.state",
-    "type_": "_var_type",
-    "is_local": "_var_is_local",
-    "is_string": "_var_is_string",
-    "set_state": "_var_set_state",
-    "deps": "_deps",
-}