instaui 0.2.2__py2.py3-none-any.whl → 0.3.0__py2.py3-none-any.whl

instaui/arco/components/select.py

@@ -45,7 +45,8 @@ class Select(Element):
             )
 
         with self.add_slot("default"):
-            with ui.vfor.from_dict(options) as item:  # type: ignore
+            with ui.vfor(options) as item:
+                item = ui.iter_info(item)
                 Select.Option(item.dict_value).props(
                     {"value": item.dict_key, "label": item.dict_value}
                 )

instaui/components/component.py

@@ -44,6 +44,8 @@ class Component(Jsonable):
         self._slot_manager.default.__exit__(*_)
 
     def _to_json_dict(self) -> Dict:
-        return {
+        data: Dict = {
             "tag": self._tag,
         }
+
+        return data

instaui/components/element.py

@@ -23,7 +23,6 @@ from typing import (
 from typing_extensions import Self
 from collections import defaultdict
 from instaui.runtime._app import get_app_slot
-from instaui.runtime._app import get_current_scope
 from instaui.vars.element_ref import ElementRef
 from instaui.vars.vfor_item import VForItem
 from instaui.components.directive import Directive
@@ -468,9 +467,7 @@ class Element(Component):
             )
 
         if self.__element_ref:
-            scope = get_current_scope()
-            data["eRef"] = self.__element_ref._to_element_config()
-            scope.register_element_ref(self.__element_ref)
+            data["eRef"] = self.__element_ref._to_element_binding_config()
 
         return data
 

instaui/components/match.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import typing
 from instaui.components.component import Component
-from instaui.runtime._app import new_scope
 
 from instaui.vars.mixin_types.element_binding import ElementBindingProtocol
 
@@ -11,96 +10,33 @@ class Match(Component):
     def __init__(self, on: ElementBindingProtocol):
         super().__init__("match")
         self._on = on
-        self._default_case = None
+        self.cass_id_count = -1
+        self._case_values = []
 
-    def _to_json_dict(self):
-        data = super()._to_json_dict()
-        data["props"] = {
-            "on": self._on._to_element_binding_config(),
-        }
-        props: typing.Dict = data["props"]
-
-        props["case"] = [
-            item
-            for item in self._slot_manager.default._children
-            if isinstance(item, Case)
-        ]
-
-        if self._default_case:
-            props["default"] = self._default_case
-
-        data.pop("slots", None)
-
-        return data
-
-    def case(self, value: typing.Any) -> Case:
-        with self:
-            case = Case(value)
-
-        return case
-
-    def default(self) -> DefaultCase:
-        with self:
-            self._default_case = DefaultCase()
-
-        return self._default_case
-
-
-class Case(Component):
-    def __init__(self, value: typing.Any):
-        super().__init__("case")
-        self._value = value
-        self.__scope_manager = new_scope()
-        self.__scope = None
+    def case(self, value: typing.Any):
+        self.cass_id_count += 1
+        self._case_values.append(value)
+        return self._slot_manager.get_slot(str(self.cass_id_count))
 
-    def __enter__(self):
-        self.__scope = self.__scope_manager.__enter__()
-        return super().__enter__()
-
-    def __exit__(self, *_) -> None:
-        self.__scope_manager.__exit__(*_)
-        return super().__exit__(*_)
+    def default(self):
+        return self._slot_manager.get_slot(":default")
 
     def _to_json_dict(self):
         data = super()._to_json_dict()
-        data["props"] = {
-            "value": self._value,
-        }
-        props = data["props"]
-
-        props["scopeId"] = self.__scope.id  # type: ignore
-
-        if self._slot_manager.has_slot():
-            props["items"] = self._slot_manager
-
-        data.pop("slots", None)
-        return data
-
+        data["on"] = self._on._to_element_binding_config()
+        data["caseValues"] = self._case_values
 
-class DefaultCase(Component):
-    def __init__(self):
-        super().__init__("default-case")
-
-        self.__scope_manager = new_scope()
-        self.__scope = None
-
-    def __enter__(self):
-        self.__scope = self.__scope_manager.__enter__()
-        return super().__enter__()
-
-    def __exit__(self, *_) -> None:
-        self.__scope_manager.__exit__(*_)
-        return super().__exit__(*_)
-
-    def _to_json_dict(self):
-        data = super()._to_json_dict()
-        data["props"] = {}
-        props = data["props"]
+        data["slots"] = {
+            name: slot
+            for name, slot in self._slot_manager._slots.items()
+            if name != ":"
+        }
 
-        props["scopeId"] = self.__scope.id  # type: ignore
+        default_slot = self._slot_manager.get_slot(
+            "default"
+        )._to_items_container_config()
 
-        if self._slot_manager.has_slot():
-            props["items"] = self._slot_manager
+        if "sid" in default_slot:
+            data["sid"] = default_slot["sid"]
 
-        data.pop("slots", None)
         return data

instaui/components/slot.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict, List, Optional, Set
+from typing import TYPE_CHECKING, Dict, List, Optional
 from instaui.common.jsonable import Jsonable
 from instaui.runtime import get_slot_stacks, pop_slot
-from instaui.runtime._app import get_app_slot
+from instaui.runtime._app import ready_scope
 from instaui.vars.slot_prop import BindingSlotPropItem
 
 if TYPE_CHECKING:
@@ -30,13 +30,6 @@ class SlotManager(Jsonable):
         return self.get_slot(_DEFAULT_SLOT_NAME)
 
     def _to_json_dict(self):
-        if (
-            len(self._slots) == 1
-            and _DEFAULT_SLOT_NAME in self._slots
-            and (not self._slots[_DEFAULT_SLOT_NAME]._has_props_use())
-        ):
-            return self._slots[_DEFAULT_SLOT_NAME]._children
-
         return {name: slot._to_json_dict() for name, slot in self._slots.items()}
 
     def has_slot(self) -> bool:
@@ -50,23 +43,28 @@ class Slot(Jsonable):
         self._id: Optional[str] = None
         self._name = name
         self._children: List[Component] = []
-        self._props_use_name: Set[str] = set()
-
-    def _has_props_use(self):
-        return len(self._props_use_name) > 0
+        self._use_slot_props: bool = False
+        self._scope_wrapper = ready_scope()
+        self._slot_prop_info = SlotPropInfo(self._scope_wrapper)
 
     def props(self, name: str):
-        if self._id is None:
-            self._id = get_app_slot().generate_slot_id()
+        self._use_slot_props = True
+        self._slot_prop_info.setup()
+
+        item = BindingSlotPropItem(
+            name, self._slot_prop_info.sid, self._slot_prop_info.var_id
+        )
 
-        self._props_use_name.add(name)
-        return BindingSlotPropItem(self._id, name)
+        return item[name]
 
     def __enter__(self):
         get_slot_stacks().append(self)
+        self._scope_wrapper.enter()
+
         return self
 
     def __exit__(self, *_):
+        self._scope_wrapper.exit()
         pop_slot()
 
     def _to_json_dict(self):
@@ -75,7 +73,43 @@ class Slot(Jsonable):
         if self._children:
             data["items"] = self._children
 
-        if self._props_use_name:
-            data["props"] = {"id": self._id, "use": list(self._props_use_name)}
+        if self._use_slot_props:
+            data["use_prop"] = 1
+
+        if self._scope_wrapper.used and self._scope_wrapper.scope.has_registered_task:
+            data["sid"] = self._scope_wrapper.scope_id
 
         return data
+
+    def _to_items_container_config(self) -> Dict:
+        data = self._to_json_dict()
+
+        return {k: v for k, v in data.items() if k in ("items", "sid")}
+
+
+class SlotPropInfo(Jsonable):
+    def __init__(self, scope_wrapper: ready_scope):
+        pass
+
+        self._scope_wrapper = scope_wrapper
+        self.__register_info = None
+
+    def setup(self):
+        if self.__register_info is not None:
+            return
+        scope = self._scope_wrapper.scope
+        self.__register_info = scope.register_slot_prop_info_task(self)
+
+    @property
+    def sid(self) -> str:
+        return self.__register_info.scope_id  # type: ignore
+
+    @property
+    def var_id(self) -> str:
+        return self.__register_info.var_id  # type: ignore
+
+    def _to_json_dict(self):
+        return {
+            "sid": self.sid,
+            "id": self.var_id,
+        }

instaui/components/vfor.py

@@ -2,19 +2,18 @@ from __future__ import annotations
 from typing import (
     Dict,
     Literal,
-    Mapping,
     Optional,
     Union,
     Sequence,
     Generic,
     TypeVar,
+    cast,
     overload,
 )
-import pydantic
+from enum import Enum
 
 from instaui.components.component import Component
-from instaui.vars.vfor_item import VForItem, VForDict, VForWithIndex
-from instaui.runtime._app import get_app_slot, new_scope
+from instaui.vars.vfor_item import VForItem
 
 from instaui.vars.mixin_types.element_binding import (
     ElementBindingMixin,
@@ -24,10 +23,16 @@ from instaui.vars.mixin_types.element_binding import (
 _T = TypeVar("_T")
 
 
+class VForArrayTypeEnum(Enum):
+    CONST = "c"
+    REF = "r"
+    RANGE = "n"
+
+
 class VFor(Component, Generic[_T]):
     def __init__(
         self,
-        data: Union[Sequence[_T], ElementBindingProtocol],
+        data: Union[Sequence[_T], ElementBindingProtocol, Dict[str, _T], _T],
         *,
         key: Union[Literal["item", "index"], str] = "index",
     ):
@@ -53,20 +58,12 @@ class VFor(Component, Generic[_T]):
         super().__init__("vfor")
         self._data = data
         self._key = key
-        self._fid = get_app_slot().generate_vfor_id()
-        self.__scope_manager = new_scope()
-        self.__scope = None
         self._num = None
         self._transition_group_setting = None
 
     def __enter__(self) -> _T:
-        self.__scope = self.__scope_manager.__enter__()
         super().__enter__()
-        return VForItem(self).proxy  # type: ignore
-
-    def __exit__(self, *_) -> None:
-        self.__scope_manager.__exit__(*_)
-        return super().__exit__(*_)
+        return cast(_T, VForItem())
 
     def _set_num(self, num):
         self._num = num
@@ -75,41 +72,41 @@ class VFor(Component, Generic[_T]):
         self._transition_group_setting = {"name": name, "tag": tag}
         return self
 
-    @property
-    def current(self):
-        return VForItem(self)
-
-    def with_index(self):
-        return VForWithIndex(self)
-
     def _to_json_dict(self):
         data = super()._to_json_dict()
-        data["props"] = {"fid": self._fid}
 
-        props: Dict = data["props"]
         if self._key is not None and self._key != "index":
-            props["fkey"] = self._key
-
-        if self._data is not None:
-            if isinstance(self._data, ElementBindingMixin):
-                props["bArray"] = self._data._to_element_binding_config()
-            else:
-                props["array"] = self._data
-
-        if self._num is not None:
-            props["num"] = self._num
+            data["fkey"] = self._key
+
+        if self._data is not None or self._num is not None:
+            array_type = (
+                VForArrayTypeEnum.REF
+                if isinstance(self._data, ElementBindingMixin)
+                else VForArrayTypeEnum.RANGE
+                if self._num is not None
+                else VForArrayTypeEnum.CONST
+            )
+
+            array_value = (
+                self._data._to_element_binding_config()
+                if isinstance(self._data, ElementBindingMixin)
+                else self._num
+                if self._num is not None
+                else self._data
+            )
+
+            data["array"] = {"type": array_type, "value": array_value}
 
         if self._transition_group_setting is not None:
-            props["tsGroup"] = {
+            data["tsGroup"] = {
                 k: v for k, v in self._transition_group_setting.items() if v is not None
             }
 
-        props["scopeId"] = self.__scope.id  # type: ignore
-
         if self._slot_manager.has_slot():
-            props["items"] = self._slot_manager
-
-        data.pop("slots", None)
+            slot_data = self._slot_manager.get_slot(
+                "default"
+            )._to_items_container_config()
+            data.update(slot_data)
 
         return data
 
@@ -135,8 +132,6 @@ class VFor(Component, Generic[_T]):
 
         return obj  # type: ignore
 
-    @classmethod
-    def from_dict(
-        cls, data: Union[Mapping, pydantic.BaseModel, ElementBindingProtocol]
-    ):
-        return VForDict(VFor(data))  # type: ignore
+
+def iter_info(item: _T) -> VForItem[_T]:
+    return cast(VForItem[_T], item)

instaui/components/vif.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
-from typing import Dict, cast
+from typing import cast
 from instaui.components.component import Component
-from instaui.runtime._app import new_scope
 from instaui.vars.mixin_types.element_binding import ElementBindingMixin
 from instaui.vars.types import TMaybeRef
 
@@ -10,31 +9,20 @@ class VIf(Component):
     def __init__(self, on: TMaybeRef[bool]):
         super().__init__("vif")
         self._on = cast(ElementBindingMixin, on)
-        self.__scope_manager = new_scope()
-        self.__scope = None
-
-    def __enter__(self):
-        self.__scope = self.__scope_manager.__enter__()
-        return super().__enter__()
-
-    def __exit__(self, *_) -> None:
-        self.__scope_manager.__exit__(*_)
-        return super().__exit__(*_)
 
     def _to_json_dict(self):
         data = super()._to_json_dict()
-        data["props"] = {
-            "on": self._on
-            if isinstance(self._on, bool)
-            else self._on._to_element_binding_config(),
-        }
-        props: Dict = data["props"]
 
-        props["scopeId"] = self.__scope.id  # type: ignore
+        data["on"] = (
+            self._on
+            if isinstance(self._on, bool)
+            else self._on._to_element_binding_config()
+        )
 
         if self._slot_manager.has_slot():
-            props["items"] = self._slot_manager
-
-        data.pop("slots", None)
+            slot_data = self._slot_manager.get_slot(
+                "default"
+            )._to_items_container_config()
+            data.update(slot_data)
 
         return data

instaui/event/js_event.py

@@ -1,5 +1,10 @@
 import typing
-from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.vars.mixin_types.py_binding import (
+    CanInputMixin,
+    CanOutputMixin,
+    inputs_to_config,
+    outputs_to_config,
+)
 from instaui.common.jsonable import Jsonable
 from .event_mixin import EventMixin
 
@@ -16,11 +21,8 @@ class JsEvent(Jsonable, EventMixin):
         ]
         self._org_inputs = list(inputs or [])
         self._org_outputs = list(outputs or [])
-        self._inputs = [
-            input._to_input_config() if isinstance(input, CanInputMixin) else input
-            for input in inputs or []
-        ]
-        self._outputs = [output._to_output_config() for output in outputs or []]
+        self._inputs = inputs or []
+        self._outputs = outputs or []
         self.code = code
 
     def _to_json_dict(self):
@@ -28,10 +30,10 @@ class JsEvent(Jsonable, EventMixin):
         data["type"] = self.event_type()
 
         if self._inputs:
-            data["inputs"] = self._inputs
+            data["inputs"] = inputs_to_config(self._inputs)
 
         if self._outputs:
-            data["set"] = self._outputs
+            data["sets"] = outputs_to_config(self._outputs)
 
         if sum(self._is_const_data) > 0:
             data["data"] = self._is_const_data

instaui/event/vue_event.py

@@ -1,6 +1,7 @@
 import typing
 from instaui.common.jsonable import Jsonable
-from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.mixin_types.py_binding import CanInputMixin
+from instaui.vars._types import InputBindingType
 from .event_mixin import EventMixin
 
 
@@ -36,21 +37,6 @@ class VueEvent(Jsonable, EventMixin):
         self.code = code
         self._bindings = bindings
 
-        if bindings:
-            bindData = [
-                int(not isinstance(v, ObservableMixin)) for v in bindings.values()
-            ]
-
-            if sum(bindData) > 0:
-                self.bindData = bindData
-
-            self.bind = {
-                k: typing.cast(ObservableMixin, v)._to_observable_config()
-                if isinstance(v, ObservableMixin)
-                else v
-                for k, v in bindings.items()
-            }
-
     def copy_with_extends(self, extends: typing.Dict):
         raise NotImplementedError("VueEvent does not support extends")
 
@@ -60,6 +46,18 @@ class VueEvent(Jsonable, EventMixin):
     def _to_json_dict(self):
         data = super()._to_json_dict()
         data["type"] = self.event_type()
+        if self._bindings:
+            data["inputs"] = {
+                name: {
+                    "value": v._to_input_config()
+                    if isinstance(v, CanInputMixin)
+                    else v,
+                    "type": v._to_event_input_type().value
+                    if isinstance(v, CanInputMixin)
+                    else InputBindingType.Data,
+                }
+                for name, v in self._bindings.items()
+            }
         return data
 
 

instaui/event/web_event.py

@@ -7,6 +7,8 @@ from instaui.vars.mixin_types.py_binding import (
     CanInputMixin,
     CanOutputMixin,
     _assert_outputs_be_can_output_mixin,
+    inputs_to_config,
+    outputs_to_config,
 )
 from instaui.handlers import event_handler
 from instaui import pre_setup as _pre_setup
@@ -74,15 +76,10 @@ class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
         data["sid"] = self._sid
 
         if self._inputs:
-            data["bind"] = [
-                binding._to_input_config()
-                if isinstance(binding, CanInputMixin)
-                else binding
-                for binding in self._inputs
-            ]
+            data["inputs"] = inputs_to_config(self._inputs)
 
         if self._outputs:
-            data["set"] = [ref._to_output_config() for ref in self._outputs]
+            data["sets"] = outputs_to_config(self._outputs)
 
         if self._pre_setup:
             data["preSetup"] = _pre_setup.convert_config(self._pre_setup)

instaui/html_tools.py

@@ -87,8 +87,14 @@ def add_vue_app_use(name: str):
 
 
 def to_config_data() -> Dict:
-    return dumps2dict(get_app_slot())
+    app = get_app_slot()
+    data = dumps2dict(app)
+
+    # Exclude scopes that contain only the id field.
+    scopes = [s for s in dumps2dict(app._scopes) if len(s) > 1]
+    data["scopes"] = scopes
+    return data
 
 
 def to_json(indent=False):
-    return dumps(get_app_slot(), indent=indent)
+    return dumps(to_config_data(), indent=indent)

instaui/js/fn.py

@@ -1,6 +1,7 @@
 from instaui.common.jsonable import Jsonable
+from instaui.vars._types import InputBindingType
 from instaui.vars.mixin_types.py_binding import CanInputMixin
-from instaui.runtime._app import get_app_slot
+from instaui.runtime._app import get_app_slot, get_current_scope
 
 
 class JsFn(Jsonable, CanInputMixin):
@@ -21,26 +22,28 @@ class JsFn(Jsonable, CanInputMixin):
         ui.label(result)
     """
 
-    def __init__(self, code: str, *, execute_immediately=False):
+    def __init__(self, code: str, *, execute_immediately=False, global_scope=False):
         self.code = code
-        self.__type = "jsFn"
-        app = get_app_slot()
-        app.register_js_fn(self)
-        self.__id = app.generate_js_fn_id()
+
+        scope = get_app_slot().top_scope if global_scope else get_current_scope()
+        self.__register_info = scope.register_js_fn_task(self)
+
         self._execute_immediately = execute_immediately
 
     def _to_input_config(self):
         return {
-            "type": self.__type,
-            "id": self.__id,
+            "sid": self.__register_info.scope_id,
+            "id": self.__register_info.var_id,
         }
 
     def _to_json_dict(self):
         data = super()._to_json_dict()
-        data["type"] = self.__type
-        data["id"] = self.__id
+        data["id"] = self.__register_info.var_id
 
         if self._execute_immediately is True:
             data["immediately"] = 1
 
         return data
+
+    def _to_event_input_type(self) -> InputBindingType:
+        return InputBindingType.JsFn

instaui/runtime/__init__.py

@@ -6,7 +6,7 @@ from ._app import (
     get_slot_stacks,
     pop_slot,
     get_current_scope,
-    new_scope,
+    ready_scope,
     check_default_app_slot_or_error,
     in_default_app_slot,
 )
@@ -15,7 +15,7 @@ from .resource import HtmlResource
 
 __all__ = [
     "get_slot_stacks",
-    "new_scope",
+    "ready_scope",
     "get_current_scope",
     "get_app_slot",
     "reset_app_slot",