instaui 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

instaui/event/vue_event.py

@@ -0,0 +1,66 @@
+import typing
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.observable import ObservableMixin
+from .event_mixin import EventMixin
+
+
+class VueEvent(Jsonable, EventMixin):
+    """
+    Create an event object that can be bound to a UI component's event listener.
+
+    This function generates a callable event handler with optional contextual bindings.
+    The event logic is defined via a code string, which can reference bound variables.
+
+    Args:
+        code (str): A string containing the executable logic for the event handler.
+                    Typically contains a function body or expression that utilizes bound variables.
+        bindings (typing.Optional[typing.Dict[str, typing.Any]], optional): A dictionary mapping variable names to values that should be available in the
+            event handler's context. If None, no additional bindings are created.. Defaults to None.
+
+    Example:
+    .. code-block:: python
+        a = ui.state(1)
+
+        event = ui.vue_event(bindings={"a": a}, code=r'''()=> { a.value +=1}''')
+
+        html.span(a)
+        html.button("plus").on("click", event)
+    """
+
+    def __init__(
+        self,
+        *,
+        code: str,
+        bindings: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    ):
+        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")
+
+    def event_type(self):
+        return "vue"
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        data["type"] = self.event_type()
+        return data
+
+
+vue_event = VueEvent

instaui/event/web_event.py

@@ -20,8 +20,8 @@ class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
     def __init__(
         self,
         fn: typing.Callable[P, R],
-        inputs: typing.List[CanInputMixin],
-        outputs: typing.List[CanOutputMixin],
+        inputs: typing.Sequence[CanInputMixin],
+        outputs: typing.Sequence[CanOutputMixin],
     ):
         self._inputs = inputs
         self._outputs = outputs
@@ -36,7 +36,7 @@ class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
     def copy_with_extends(self, extends: typing.Sequence[CanInputMixin]):
         return WebEvent(
             fn=self._fn,
-            inputs=self._inputs + list(extends),
+            inputs=list(self._inputs) + list(extends),
             outputs=self._outputs,
         )
 
@@ -76,32 +76,43 @@ class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
         return data
 
 
-@typing.overload
-def ui_event(fn: typing.Callable[P, R]) -> WebEvent[P, R]: ...
+def event(
+    *,
+    inputs: typing.Optional[typing.Sequence] = None,
+    outputs: typing.Optional[typing.Sequence] = None,
+):
+    """
+    Creates an event handler decorator for binding reactive logic to component events.
 
+    Args:
+        inputs (typing.Optional[typing.Sequence], optional): Reactive sources (state objects, computed properties)
+                                   that should be accessible during event handling.
+                                   These values will be passed to the decorated function
+                                   when the event fires.
+        outputs (typing.Optional[typing.Sequence], optional): Targets (state variables, UI elements) that should
+                                    update when this handler executes. Used for coordinating
+                                    interface updates after the event is processed.
 
-@typing.overload
-def ui_event(
-    *,
-    inputs: typing.Optional[typing.Union[_T_input, typing.Sequence[_T_input]]] = None,
-    outputs: typing.Optional[
-        typing.Union[_T_output, typing.Sequence[_T_output]]
-    ] = None,
-) -> typing.Callable[[typing.Callable[P, R]], WebEvent[P, R]]: ...
+    # Example:
+    .. code-block:: python
+        from instaui import ui, html
+
+        a = ui.state(0)
 
+        @ui.event(inputs=[a], outputs=[a])
+        def plus_one(a):
+            return a + 1
 
-def ui_event(
-    fn: typing.Optional[typing.Callable[P, R]] = None, *, inputs=None, outputs=None
-) -> typing.Union[
-    WebEvent[P, R], typing.Callable[[typing.Callable[P, R]], WebEvent[P, R]]
-]:
-    inputs = [inputs] if isinstance(inputs, CanInputMixin) else inputs
-    outputs = [outputs] if isinstance(outputs, CanOutputMixin) else outputs
-    if fn is None:
+        html.button("click me").on_click(plus_one)
+        html.paragraph(a)
 
-        def wrapper(fn: typing.Callable[P, R]):
-            return WebEvent(fn, inputs=inputs or [], outputs=outputs or [])
+    """
 
-        return wrapper
+    def wrapper(func: typing.Callable[P, R]):
+        return WebEvent(
+            func,
+            inputs or [],
+            outputs=outputs or [],
+        )
 
-    return WebEvent(fn, inputs=inputs or [], outputs=outputs or [])
+    return wrapper

instaui/experimental/__init__.py

@@ -1,4 +1,3 @@
 from .debug import list_all_bindables
-from instaui.vars.state import state
 
-__all__ = ["list_all_bindables", "state"]
+__all__ = ["list_all_bindables"]

instaui/handlers/_utils.py

@@ -23,17 +23,20 @@ class HandlerInfo:
     fn: Callable
     fn_location_info: str
     outputs_binding_count: int = 0
-    hanlder_param_converters: List[pydantic_system.TypeAdapterProtocol] = field(
+    handler_param_converters: List[pydantic_system.TypeAdapterProtocol] = field(
         default_factory=list
     )
+    is_last_param_args: bool = False
 
     def get_handler_args(self, input_values: List):
+        real_param_converters = _try_expand_params_converters(
+            self.handler_param_converters, input_values, self.is_last_param_args
+        )
+
         try:
             return [
                 param_converter.to_python_value(value)
-                for param_converter, value in zip(
-                    self.hanlder_param_converters, input_values
-                )
+                for param_converter, value in zip(real_param_converters, input_values)
             ]
         except pydantic_core._pydantic_core.ValidationError as e:
             raise ValueError(f"invalid input[{self.fn_location_info}]: {e}") from None
@@ -49,6 +52,7 @@ class HandlerInfo:
     ):
         custom_type_adapter_map = custom_type_adapter_map or {}
         params_infos = func_system.get_fn_params_infos(handler)
+        is_last_param_args = func_system.is_last_param_args(handler)
         param_converters = [
             custom_type_adapter_map.get(
                 idx, pydantic_system.create_type_adapter(param_type)
@@ -62,5 +66,23 @@ class HandlerInfo:
             handler,
             f'File "{file}", line {lineno}',
             outputs_binding_count,
-            hanlder_param_converters=param_converters,
+            handler_param_converters=param_converters,
+            is_last_param_args=is_last_param_args,
         )
+
+
+def _try_expand_params_converters(
+    old_param_converters: List[pydantic_system.TypeAdapterProtocol],
+    input_values: List,
+    is_last_param_args: bool,
+):
+    if not is_last_param_args:
+        return old_param_converters
+
+    diff = len(input_values) - len(old_param_converters)
+    if diff == 0:
+        return old_param_converters
+
+    arg_param_converters = [old_param_converters[-1]] * diff
+
+    return [*old_param_converters[:], *arg_param_converters]