instaui 0.1.17__py2.py3-none-any.whl → 0.1.19__py2.py3-none-any.whl

instaui/components/component.py

@@ -29,8 +29,6 @@ class Component(Jsonable):
                 else str(tag)
             )
         )
-        if isinstance(tag, ElementBindingMixin):
-            tag._mark_used()
         self._slot_manager = SlotManager()
 
         get_app_slot().append_component_to_container(self)

instaui/components/element.py

@@ -271,28 +271,18 @@ class Element(Component):
 
         if isinstance(add, dict):
             self._dict_classes.update(**add)  # type: ignore
-            for value in (
-                v for v in add.values() if isinstance(v, ElementBindingMixin)
-            ):
-                value._mark_used()
 
         if isinstance(add, ElementBindingMixin):
             self._bind_str_classes.append(add)  # type: ignore
-            add._mark_used()
 
         return self
 
     def style(self, add: Union[str, Dict[str, Any], TMaybeRef[str]]) -> Self:
         if isinstance(add, dict):
             add = {key: value for key, value in add.items()}
-            for value in (
-                v for v in add.values() if isinstance(v, ElementBindingMixin)
-            ):
-                value._mark_used()
 
         if isinstance(add, ElementBindingMixin):
             self._style_str_binds.append(add)
-            add._mark_used()
             return self
 
         new_style = self._parse_style(add)
@@ -302,17 +292,11 @@ class Element(Component):
     def props(self, add: Union[str, Dict[str, Any], TMaybeRef]) -> Self:
         if isinstance(add, ElementBindingMixin):
             self._proxy_props.append(add)
-            add._mark_used()
             return self
 
         if isinstance(add, dict):
             add = {key: value for key, value in add.items() if value is not None}
 
-            for value in (
-                v for v in add.values() if isinstance(v, ElementBindingMixin)
-            ):
-                value._mark_used()
-
         new_props = self._parse_props(add)
         self._props.update(new_props)
         return self

instaui/components/match.py

@@ -11,8 +11,6 @@ class Match(Component):
     def __init__(self, on: ElementBindingMixin):
         super().__init__("match")
         self._on = on
-        if isinstance(on, ElementBindingMixin):
-            on._mark_used()
         self._default_case = None
 
     def _to_json_dict(self):
@@ -52,7 +50,7 @@ class Case(Component):
     def __init__(self, value: typing.Any):
         super().__init__("case")
         self._value = value
-        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope_manager = new_scope()
         self.__scope = None
 
     def __enter__(self):
@@ -70,7 +68,7 @@ class Case(Component):
         }
         props = data["props"]
 
-        props["scope"] = self.__scope
+        props["scopeId"] = self.__scope.id  # type: ignore
 
         if self._slot_manager.has_slot():
             props["items"] = self._slot_manager
@@ -83,7 +81,7 @@ class DefaultCase(Component):
     def __init__(self):
         super().__init__("default-case")
 
-        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope_manager = new_scope()
         self.__scope = None
 
     def __enter__(self):
@@ -99,7 +97,7 @@ class DefaultCase(Component):
         data["props"] = {}
         props = data["props"]
 
-        props["scope"] = self.__scope
+        props["scopeId"] = self.__scope.id  # type: ignore
 
         if self._slot_manager.has_slot():
             props["items"] = self._slot_manager

instaui/components/vfor.py

@@ -50,11 +50,9 @@ class VFor(Component, Generic[_T]):
 
         super().__init__("vfor")
         self._data = data
-        if isinstance(self._data, ElementBindingMixin):
-            self._data._mark_used()
         self._key = key
         self._fid = get_app_slot().generate_vfor_id()
-        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope_manager = new_scope()
         self.__scope = None
         self._num = None
         self._transition_group_setting = None
@@ -104,7 +102,7 @@ class VFor(Component, Generic[_T]):
                 k: v for k, v in self._transition_group_setting.items() if v is not None
             }
 
-        props["scope"] = self.__scope
+        props["scopeId"] = self.__scope.id  # type: ignore
 
         if self._slot_manager.has_slot():
             props["items"] = self._slot_manager

instaui/components/vif.py

@@ -10,9 +10,7 @@ class VIf(Component):
     def __init__(self, on: TMaybeRef[bool]):
         super().__init__("vif")
         self._on = cast(ElementBindingMixin, on)
-        if isinstance(on, ElementBindingMixin):
-            on._mark_used()
-        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope_manager = new_scope()
         self.__scope = None
 
     def __enter__(self):
@@ -32,7 +30,7 @@ class VIf(Component):
         }
         props: Dict = data["props"]
 
-        props["scope"] = self.__scope
+        props["scopeId"] = self.__scope.id  # type: ignore
 
         if self._slot_manager.has_slot():
             props["items"] = self._slot_manager

instaui/event/js_event.py

@@ -1,6 +1,5 @@
 import typing
 from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
-from instaui.vars.mixin_types.element_binding import _try_mark_inputs_used
 from instaui.common.jsonable import Jsonable
 from .event_mixin import EventMixin
 
@@ -27,7 +26,6 @@ class JsEvent(Jsonable, EventMixin):
     def _to_json_dict(self):
         data = super()._to_json_dict()
         data["type"] = self.event_type()
-        _try_mark_inputs_used(self._org_inputs)
 
         if self._inputs:
             data["inputs"] = self._inputs

instaui/event/vue_event.py

@@ -1,7 +1,6 @@
 import typing
 from instaui.common.jsonable import Jsonable
 from instaui.vars.mixin_types.observable import ObservableMixin
-from instaui.vars.mixin_types.element_binding import _try_mark_inputs_used
 from .event_mixin import EventMixin
 
 
@@ -60,8 +59,6 @@ class VueEvent(Jsonable, EventMixin):
 
     def _to_json_dict(self):
         data = super()._to_json_dict()
-
-        _try_mark_inputs_used((self._bindings or {}).values())
         data["type"] = self.event_type()
         return data
 

instaui/event/web_event.py

@@ -4,7 +4,6 @@ from typing_extensions import ParamSpec
 from instaui.common.jsonable import Jsonable
 from instaui.runtime._app import get_current_scope, get_app_slot
 from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
-from instaui.vars.mixin_types.element_binding import _try_mark_inputs_used
 from instaui.handlers import event_handler
 from .event_mixin import EventMixin
 
@@ -47,8 +46,6 @@ class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
     def _to_json_dict(self):
         app = get_app_slot()
 
-        _try_mark_inputs_used(self._inputs)
-
         hkey = event_handler.create_handler_key(
             page_path=app.page_path, handler=self._fn
         )

instaui/js/fn.py

@@ -0,0 +1,42 @@
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.py_binding import CanInputMixin
+from instaui.runtime._app import get_app_slot
+
+
+class JsFn(Jsonable, CanInputMixin):
+    """
+    Creates a JavaScript function object from a raw code string.
+    Valid targets include: `js_computed`, `js_watch`, and similar JS-bound methods.
+
+    Args:
+        code (str): Valid JavaScript function definition string.
+
+    Example:
+    .. code-block:: python
+        a = ui.state(1)
+        add = ui.js_fn(code="(a,b)=> a+b ")
+        result = ui.js_computed(inputs=[add, a], code="(add,a)=>  add(a,10) ")
+
+        html.number(a)
+        ui.label(result)
+    """
+
+    def __init__(self, code: str):
+        self.code = code
+        self.__type = "jsFn"
+        app = get_app_slot()
+        app.register_js_fn(self)
+        self.__id = app.generate_js_fn_id()
+
+    def _to_input_config(self):
+        return {
+            "type": self.__type,
+            "id": self.__id,
+        }
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        data["type"] = self.__type
+        data["id"] = self.__id
+
+        return data

instaui/runtime/_app.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
     from instaui.dependencies.component_dependency import ComponentDependencyInfo
     from instaui.dependencies.plugin_dependency import PluginDependencyInfo
     from instaui.spa_router._route_model import RouteCollector
+    from instaui.js.fn import JsFn
 
 
 class App(Jsonable):
@@ -28,6 +29,7 @@ class App(Jsonable):
         self._scope_id_counter = 0
         self._vfor_id_counter = 0
         self._slot_id_counter = 0
+        self._js_fn_id_counter = 0
         self.mode: _T_App_Mode = mode
         self.items: List[Component] = []
         self.meta = meta
@@ -45,6 +47,7 @@ class App(Jsonable):
         self._page_params: Dict[str, Any] = {}
         self._query_params: Dict[str, Any] = {}
         self._route_collector: Optional[RouteCollector] = None
+        self._js_fns: List[JsFn] = []
 
     @property
     def page_path(self) -> str:
@@ -72,6 +75,13 @@ class App(Jsonable):
         self._slot_id_counter += 1
         return str(self._slot_id_counter)
 
+    def generate_js_fn_id(self) -> str:
+        self._js_fn_id_counter += 1
+        return str(self._js_fn_id_counter)
+
+    def register_js_fn(self, fn: JsFn) -> None:
+        self._js_fns.append(fn)
+
     def reset_html_resource(self):
         self._html_resource = HtmlResource()
 
@@ -116,8 +126,8 @@ class App(Jsonable):
 
             data["url"] = url_info
 
-        assert len(self._scopes) == 1, "Only one scope is allowed"
-        data["scope"] = self._scopes[0]
+        data["scopeId"] = self._scopes[0].id
+        data["scopes"] = self._scopes
 
         if self._route_collector is not None:
             data["router"] = self._route_collector.model_dump(
@@ -127,6 +137,9 @@ class App(Jsonable):
         if self._web_server_info is not None:
             data["webInfo"] = self._web_server_info
 
+        if self._js_fns:
+            data["jsFn"] = self._js_fns
+
         return data
 
     @classmethod

instaui/runtime/scope.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Callable, List
+import functools
+import weakref
 from instaui.common.jsonable import Jsonable
 
 
@@ -58,21 +60,6 @@ class Scope(Jsonable):
             "on": [v._to_input_config() for v in on],
         }
 
-    def register_ref(self, var: VarMixin) -> None:
-        self._refs.append(var)
-
-    def register_data(self, data: ConstData) -> None:
-        self._const_data.append(data)
-
-    def register_js_computed(self, computed: JsComputed) -> None:
-        self._js_computeds.append(computed)
-
-    def register_vue_computed(self, computed: VueComputed) -> None:
-        self._vue_computeds.append(computed)
-
-    def register_web_computed(self, computed: WebComputed) -> None:
-        self._web_computeds.append(computed)
-
     def register_web_watch(self, watch: WebWatch) -> None:
         self._web_watchs.append(watch)
 
@@ -82,6 +69,51 @@ class Scope(Jsonable):
     def register_vue_watch(self, watch: VueWatch) -> None:
         self._vue_watchs.append(watch)
 
+    def register_data_task(self, data: ConstData):
+        weak_obj = weakref.ref(data)
+
+        def register_fn():
+            self._const_data.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
+    def register_ref_task(self, ref: VarMixin):
+        weak_obj = weakref.ref(ref)
+
+        def register_fn():
+            self._refs.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
+    def register_js_computed_task(self, computed: JsComputed):
+        weak_obj = weakref.ref(computed)
+
+        def register_fn():
+            self._js_computeds.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
+    def register_computed_task(self, computed: WebComputed):
+        weak_obj = weakref.ref(computed)
+
+        def register_fn():
+            self._web_computeds.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
+    def register_vue_computed_task(self, computed: VueComputed):
+        weak_obj = weakref.ref(computed)
+
+        def register_fn():
+            self._vue_computeds.append(weak_obj())  # type: ignore
+            return self.generate_vars_id()
+
+        return VarRegisterTask(self.id, register_fn)
+
     def _to_json_dict(self):
         data = super()._to_json_dict()
         if self._refs:
@@ -97,23 +129,12 @@ class Scope(Jsonable):
         if self._element_refs:
             data["eRefs"] = self._element_refs
 
-        # web computeds
-        _web_computeds = [
-            computed for computed in self._web_computeds if computed._is_used()
-        ]
-
-        if _web_computeds:
-            data["web_computed"] = _web_computeds
+        if self._web_computeds:
+            data["web_computed"] = self._web_computeds
 
-        # js computeds
-        _js_computeds = [
-            computed for computed in self._js_computeds if computed._is_used()
-        ]
+        if self._js_computeds:
+            data["js_computed"] = self._js_computeds
 
-        if _js_computeds:
-            data["js_computed"] = _js_computeds
-
-        # vue computeds
         if self._vue_computeds:
             data["vue_computed"] = self._vue_computeds
         if self._const_data:
@@ -126,12 +147,18 @@ class GlobalScope(Scope):
     def __init__(self, id: str) -> None:
         super().__init__(id)
 
-    def register_ref(self, var: VarMixin) -> None:
+    def register_ref_task(self, var: VarMixin) -> None:
         raise ValueError("Can not register ref in global scope")
 
-    def register_web_computed(self, computed: WebComputed) -> None:
+    def register_computed_task(self, computed: WebComputed) -> None:
         raise ValueError("Can not register web_computeds  in global scope")
 
+    def register_js_computed_task(self, computed: JsComputed):
+        raise ValueError("Can not register js_computeds  in global scope")
+
+    def register_vue_computed_task(self, computed: VueComputed):
+        raise ValueError("Can not register vue_computeds  in global scope")
+
     def register_web_watch(self, watch: WebWatch) -> None:
         raise ValueError("Can not register web_watchs  in global scope")
 
@@ -140,3 +167,17 @@ class GlobalScope(Scope):
 
     def register_vue_watch(self, watch: VueWatch) -> None:
         raise ValueError("Can not register vue_watchs  in global scope")
+
+
+class VarRegisterTask:
+    def __init__(self, scope_id: str, register_fn: Callable[[], str]) -> None:
+        self._scope_id = scope_id
+        self._id_gen_fn = functools.lru_cache(maxsize=1)(register_fn)
+
+    @property
+    def scope_id(self) -> str:
+        return self._scope_id
+
+    @property
+    def var_id(self) -> str:
+        return self._id_gen_fn()

instaui/spa_router/_route_model.py

@@ -5,7 +5,6 @@ from pydantic import BaseModel, Field, ConfigDict, field_serializer, model_seria
 from instaui.components.html.div import Div
 from instaui.runtime._app import get_app_slot, new_scope
 from instaui.components.component import Component
-from instaui.runtime.scope import Scope
 from instaui.common.jsonable import dumps2dict
 
 from . import _types
@@ -15,7 +14,7 @@ class RouteItem(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     component_fn: typing.Optional[typing.Callable] = Field(exclude=True)
-    scope: typing.Optional[Scope] = None
+    scopeId: typing.Optional[str] = None
     vue_route_item: VueRouteItem = Field(serialization_alias="vueItem")
     meta: typing.Optional[typing.Dict] = None
 
@@ -30,20 +29,20 @@ class RouteItem(BaseModel):
             }
 
         if self.vue_route_item.path is None:
-            self.vue_route_item.path = f"/{'' if self.component_fn.__name__=='index' else self.component_fn.__name__}"
+            self.vue_route_item.path = f"/{'' if self.component_fn.__name__ == 'index' else self.component_fn.__name__}"
 
         app = get_app_slot()
-        with new_scope(append_to_app=False) as scope:
+        with new_scope() as scope:
             with Div() as div:
                 self.component_fn()
 
         app.items.pop()
 
-        self.scope = scope
+        self.scopeId = scope.id
         self.vue_route_item.component = div._slot_manager.default._children
 
         return {
-            "scope": dumps2dict(scope),
+            "scopeId": scope.id,
             "vueItem": self.vue_route_item,
         }