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

instaui/action/__init__.py

@@ -0,0 +1,10 @@
+__all__ = [
+    "url_location",
+    "set_cookie",
+    "cookie_output",
+    "cookie_input",
+]
+
+
+from .url_location import UrlLocation as url_location
+from .cookie import cookie_input, cookie_output, set_cookie

instaui/action/cookie.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+from typing import Optional, Union
+from instaui.runtime.context import get_context
+
+
+def cookie_output():
+    if not get_context().app_mode == "web":
+        raise ValueError("cookie_output can only be used in web mode")
+
+
+def cookie_input():
+    pass
+
+
+def set_cookie(
+    key: str,
+    value: str,
+    *,
+    max_age: Optional[int] = None,
+    expires: Optional[Union[int, datetime]] = None,
+    secure: bool = False,
+    httponly: bool = False,
+    samesite: Optional[str] = None,
+):
+    pass

instaui/arco/components/radio.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import typing
 from typing_extensions import Unpack
 import pydantic
@@ -6,13 +7,16 @@ from instaui.vars.types import TMaybeRef
 from instaui.vars.state import StateModel
 from instaui.arco import component_types
 from instaui.event.event_mixin import EventMixin
-from ._utils import handle_props, try_setup_vmodel
+from ._utils import handle_props
+from .radio_group import RadioGroup
+
+_TValue = typing.Union[str, float]
 
 
 class Radio(Element):
     def __init__(
         self,
-        value: typing.Optional[TMaybeRef[typing.Union[str, int, bool, float]]] = None,
+        value: typing.Optional[TMaybeRef[_TValue]] = None,
         **kwargs: Unpack[component_types.TRadio],
     ):
         super().__init__("a-radio")
@@ -33,8 +37,17 @@ class Radio(Element):
         )
         return self
 
+    @staticmethod
+    def from_list(options: TMaybeRef[typing.List[_TValue]], value: TMaybeRef[_TValue]):
+        return RadioGroup(value=value, options=options)  # type: ignore
+
+    @staticmethod
+    def from_options(
+        options: TMaybeRef[typing.List[RadioOption]], value: TMaybeRef[_TValue]
+    ):
+        return RadioGroup(value=value, options=options)  # type: ignore
 
-class RadioOption(StateModel):
-    label: str
-    value: typing.Union[str, int]
-    disabled: bool = pydantic.Field(default=False)
+    class RadioOption(StateModel):
+        label: str
+        value: typing.Union[str, int]
+        disabled: bool = pydantic.Field(default=False)

instaui/arco/components/radio_group.py

@@ -4,7 +4,6 @@ from instaui.components.element import Element
 from instaui.vars.types import TMaybeRef
 from instaui.event.event_mixin import EventMixin
 from ._utils import handle_props, try_setup_vmodel
-from .radio import RadioOption
 
 
 class TRadioGroup(TypedDict, total=False):
@@ -12,7 +11,7 @@ class TRadioGroup(TypedDict, total=False):
     default_value: typing.Union[str, int, bool]
     type: typing.Literal["radio", "button"]
     size: typing.Literal["mini", "small", "medium", "large"]
-    options: typing.List[typing.Union[str, int, RadioOption]]
+    options: typing.List[typing.Union[str, int]]
     direction: typing.Literal["horizontal", "vertical"]
     disabled: bool
 
@@ -20,7 +19,7 @@ class TRadioGroup(TypedDict, total=False):
 class RadioGroup(Element):
     def __init__(
         self,
-        value: typing.Optional[TMaybeRef[typing.Union[str, int, bool, float]]] = None,
+        value: typing.Optional[TMaybeRef[typing.Union[str, float]]] = None,
         **kwargs: Unpack[TRadioGroup],
     ):
         super().__init__("a-radio-group")

instaui/components/component.py

@@ -29,6 +29,8 @@ 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/html/__init__.py

@@ -6,6 +6,7 @@ __all__ = [
     "number",
     "button",
     "checkbox",
+    "radio",
     "form",
     "select",
     "option",
@@ -32,6 +33,7 @@ from .input import Input as input
 from .number import Number as number
 from .button import Button as button
 from .checkbox import Checkbox as checkbox
+from .radio import Radio as radio
 from .form import Form as form
 from .select import Select as select
 from .ul import Ul as ul

instaui/components/html/label.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 from instaui.components.element import Element
 
 if TYPE_CHECKING:
@@ -10,12 +10,14 @@ class Label(Element):
     def __init__(
         self,
         text: Union[Any, TMaybeRef[Any], None] = None,
+        *,
+        for_: Optional[TMaybeRef[str]] = None,
     ):
         super().__init__("label")
 
-        if text is not None:
-            self.props(
-                {
-                    "innerText": text,
-                }
-            )
+        self.props(
+            {
+                "innerText": text,
+                "for": for_,
+            }
+        )

instaui/components/html/radio.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+from instaui.components.element import Element
+from instaui.components.value_element import ValueElement
+from ._mixins import InputEventMixin
+
+if TYPE_CHECKING:
+    from instaui.vars.types import TMaybeRef
+
+
+_T_value = str
+
+
+class Radio(InputEventMixin, ValueElement[_T_value]):
+    def __init__(
+        self,
+        value: Optional[TMaybeRef[_T_value]] = None,
+        *,
+        model_value: Optional[_T_value] = None,
+        id: Optional[TMaybeRef[str]] = None,
+        name: Optional[TMaybeRef[str]] = None,
+    ):
+        super().__init__("input", value, is_html_component=True)
+        self.props({"type": "radio"})
+
+        self.props(
+            {
+                "id": id,
+                "name": name,
+            }
+        )
+
+        if model_value is not None:
+            self.props({"value": model_value})
+
+    def _input_event_mixin_element(self) -> Element:
+        return self

instaui/components/timer/timer.js

@@ -0,0 +1,48 @@
+import { ref, watch, onMounted, onUnmounted, toRef } from 'vue'
+
+
+export default {
+    props: ['intervalSeconds', 'active', 'once', 'immediate'],
+    setup(props, { emit }) {
+        const { intervalSeconds, once = false, immediate = true } = props
+        const intervalId = ref(null)
+        const isActive = toRef(() => props.active ?? true)
+        const emitTick = once ? () => { emit('tick'); stopInterval() } : () => emit('tick')
+
+        if (once === false) {
+            watch(isActive, (value) => {
+                if (value) {
+                    startInterval()
+                } else {
+                    stopInterval()
+                }
+            })
+        }
+
+        const startInterval = () => {
+            if (immediate) {
+                emitTick()
+            }
+
+            intervalId.value = setInterval(() => {
+                emitTick()
+            }, intervalSeconds * 1000)
+        }
+
+        const stopInterval = () => {
+            clearInterval(intervalId.value)
+            emit('stop')
+        }
+
+        onMounted(() => {
+            if (isActive.value) {
+                startInterval()
+            }
+        })
+
+        onUnmounted(() => {
+            stopInterval()
+        })
+    }
+
+}

instaui/components/timer/timer.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+from typing import List, Optional
+from instaui.components.element import Element
+from instaui.vars.types import TMaybeRef
+from instaui.event.event_mixin import EventMixin
+
+
+class Timer(Element, esm="./timer.js"):
+    """
+    A timer component that triggers events at specified intervals.
+
+    Args:
+        interval_seconds (float): Time in seconds between repeated events.
+        active (Optional[TMaybeRef[bool]], optional): If True, starts the timer immediately.
+            Accepts reactive values (e.g., state references) for dynamic control. Defaults to None (equivalent to True).
+        immediate (Optional[bool], optional): If True, triggers the first event immediately. Defaults to None (equivalent to True).
+
+    Example:
+    .. code-block:: python
+        from instaui import ui, html
+
+        @ui.page('/')
+        def index():
+            x = ui.state(0)
+            active = ui.state(True)
+
+            @ui.event(inputs=[x], outputs=[x])
+            def on_tick(x):
+                return x + 1
+
+            ui.timer(1, active=active).on_tick(on_tick)
+
+            html.checkbox(active)
+            html.span(x)
+    """
+
+    def __init__(
+        self,
+        interval_seconds: float,
+        *,
+        active: Optional[TMaybeRef[bool]] = None,
+        immediate: Optional[bool] = None,
+    ):
+        super().__init__("template")
+
+        self.props(
+            {
+                "intervalSeconds": interval_seconds,
+                "active": active,
+                "immediate": immediate,
+            }
+        )
+
+    def on_tick(
+        self,
+        handler: EventMixin,
+        *,
+        extends: Optional[List] = None,
+    ):
+        """
+        Registers an event handler for the "tick" event.
+        """
+        return self.on("tick", handler, extends=extends)
+
+    def on_stop(
+        self,
+        handler: EventMixin,
+        *,
+        extends: Optional[List] = None,
+    ):
+        """
+        Registers an event handler for the "stop" event.
+        """
+
+        return self.on("stop", handler, extends=extends)
+
+    @classmethod
+    def once(cls, delay_seconds: float):
+        """
+        Creates a timer that triggers only once.
+
+        Args:
+            delay_seconds (float): Time in seconds before the timer triggers.
+
+        Example:
+        .. code-block:: python
+            msg = ui.state('')
+            on_done = ui.js_event(outputs=[msg],code="()=> 'Done!'")
+
+            ui.timer.once(1).on_tick(on_done)
+            html.span(msg) # will show "Done!" after 1 second
+
+        """
+        return cls(delay_seconds, immediate=False).props({"once": True})

instaui/event/js_event.py

@@ -1,5 +1,6 @@
 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
 
@@ -26,6 +27,7 @@ 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,6 +1,7 @@
 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
 
 
@@ -59,6 +60,8 @@ 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,7 @@ 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 ElementBindingMixin
+from instaui.vars.mixin_types.element_binding import _try_mark_inputs_used
 from instaui.handlers import event_handler
 from .event_mixin import EventMixin
 
@@ -47,9 +47,7 @@ class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
     def _to_json_dict(self):
         app = get_app_slot()
 
-        for _input in self._inputs:
-            if isinstance(_input, ElementBindingMixin):
-                _input._mark_used()
+        _try_mark_inputs_used(self._inputs)
 
         hkey = event_handler.create_handler_key(
             page_path=app.page_path, handler=self._fn

instaui/runtime/scope.py

@@ -97,14 +97,23 @@ 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._js_computeds:
-            data["js_computed"] = self._js_computeds
+
+        # js computeds
+        _js_computeds = [
+            computed for computed in self._js_computeds if computed._is_used()
+        ]
+
+        if _js_computeds:
+            data["js_computed"] = _js_computeds
+
+        # vue computeds
         if self._vue_computeds:
             data["vue_computed"] = self._vue_computeds
         if self._const_data: