instaui 0.1.0__py3-none-any.whl

instaui/components/html/date.py

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

instaui/components/html/div.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from instaui.components.element import Element
+
+
+class Div(Element):
+    def __init__(self):
+        super().__init__("div")

instaui/components/html/form.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+from instaui.components.element import Element
+
+
+class Form(Element):
+    def __init__(self):
+        super().__init__("form")

instaui/components/html/input.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Union
+from instaui.components.element import Element
+from instaui.components.value_element import ValueElement
+
+from ._mixins import InputEventMixin
+
+if TYPE_CHECKING:
+    import instaui.vars as ui_vars
+
+
+class Input(InputEventMixin, ValueElement[str]):
+    def __init__(
+        self,
+        value: Union[str, ui_vars.TMaybeRef[str], None] = None,
+        *,
+        model_value: Union[str, ui_vars.TMaybeRef[str], None] = None,
+        disabled: Optional[ui_vars.TMaybeRef[bool]] = None,
+    ):
+        super().__init__("input", value, is_html_component=True)
+
+        if disabled is not None:
+            self.props({"disabled": disabled})
+        if model_value is not None:
+            self.props({"value": model_value})
+
+    def _input_event_mixin_element(self) -> Element:
+        return self

instaui/components/html/label.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Union
+from instaui.components.element import Element
+
+if TYPE_CHECKING:
+    import instaui.vars as ui_vars
+
+
+class Label(Element):
+    def __init__(
+        self,
+        text: Union[Any, ui_vars.TMaybeRef[Any], None] = None,
+    ):
+        super().__init__("label")
+
+        if text is not None:
+            self.props(
+                {
+                    "innerText": text,
+                }
+            )

instaui/components/html/li.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Union
+from instaui.components.element import Element
+
+if TYPE_CHECKING:
+    from instaui.vars import TMaybeRef
+
+
+class Li(Element):
+    def __init__(
+        self,
+        text: Union[Any, TMaybeRef[Any], None] = None,
+    ):
+        super().__init__("li")
+
+        if text:
+            self.props({"innerText": text})

instaui/components/html/link.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+from typing import (
+    Optional,
+)
+from instaui.components.element import Element
+
+from instaui.vars.types import TMaybeRef
+
+
+class Link(Element):
+    def __init__(
+        self,
+        href: Optional[TMaybeRef[str]] = None,
+        *,
+        text: Optional[TMaybeRef[str]] = None,
+    ):
+        super().__init__("a")
+
+        if text is not None:
+            self.props(
+                {
+                    "innerText": text,
+                }
+            )
+
+        if href is not None:
+            self.props(
+                {
+                    "href": href,
+                }
+            )

instaui/components/html/number.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Union
+from instaui.components.element import Element
+from instaui.components.value_element import ValueElement
+from ._mixins import InputEventMixin
+
+if TYPE_CHECKING:
+    import instaui.vars as ui_vars
+
+
+_T_value = Union[int, float]
+
+
+class Number(InputEventMixin, ValueElement[_T_value]):
+    def __init__(
+        self,
+        value: Optional[ui_vars.TMaybeRef[_T_value]] = None,
+        *,
+        model_value: Optional[ui_vars.TMaybeRef[_T_value]] = None,
+        min: Optional[ui_vars.TMaybeRef[_T_value]] = None,
+        max: Optional[ui_vars.TMaybeRef[_T_value]] = None,
+    ):
+        super().__init__("input", value, is_html_component=True)
+        self.props({"type": "number"})
+
+        if min is not None:
+            self.props({"min": min})
+        if max is not None:
+            self.props({"max": max})
+        if model_value is not None:
+            self.props({"value": model_value})
+
+    def _input_event_mixin_element(self) -> Element:
+        return self

instaui/components/html/paragraph.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Union
+from instaui.components.element import Element
+
+if TYPE_CHECKING:
+    import instaui.vars as ui_vars
+
+
+class Paragraph(Element):
+    def __init__(
+        self,
+        text: Union[str, ui_vars.TMaybeRef[Any]],
+    ):
+        super().__init__("p")
+        self.props(
+            {
+                "innerText": text,
+            }
+        )

instaui/components/html/range.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+from typing import List, Union
+from instaui.components.element import Element
+from instaui.components.value_element import ValueElement
+from instaui import consts
+from instaui.vars.types import TMaybeRef
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from ._mixins import InputEventMixin
+
+_T_value = Union[int, float]
+
+
+class Range(InputEventMixin, ValueElement[_T_value]):
+    def __init__(
+        self,
+        value: Union[_T_value, TMaybeRef[_T_value], None] = None,
+        *,
+        min: Union[_T_value, TMaybeRef[_T_value], None] = None,
+        max: Union[_T_value, TMaybeRef[_T_value], None] = None,
+    ):
+        super().__init__("input", value, is_html_component=True)
+        self.props({"type": "range"})
+
+        if min is not None:
+            self.props({"min": min})
+        if max is not None:
+            self.props({"max": max})
+
+    def vmodel(
+        self,
+        value: ElementBindingMixin,
+        modifiers: Union[consts.TModifier, List[consts.TModifier], None] = None,
+        *,
+        prop_name: str = "value",
+    ):
+        modifiers = modifiers or []
+        if isinstance(modifiers, str):
+            modifiers = [modifiers]
+
+        modifiers_with_number = list(set([*modifiers, "number"]))
+
+        return super().vmodel(value, modifiers_with_number, prop_name=prop_name)  # type: ignore
+
+    def _input_event_mixin_element(self) -> Element:
+        return self

instaui/components/html/select.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Self,
+    Union,
+    overload,
+)
+
+from instaui.vars import Ref
+from instaui.components.value_element import ValueElement
+from instaui.components.element import Element
+from instaui.vars.types import TMaybeRef
+from instaui.components.vfor import VFor
+
+if TYPE_CHECKING:
+    import instaui.vars as ui_vars
+
+
+_T_Select_Value = Union[List[str], str]
+
+
+class Select(ValueElement[Union[List[str], str]]):
+    def __init__(
+        self,
+        value: Union[_T_Select_Value, ui_vars.TMaybeRef[_T_Select_Value], None] = None,
+    ):
+        super().__init__("select", value, is_html_component=True)
+
+    def vmodel(
+        self,
+        value: Ref[Any],
+        *modifiers: Literal["lazy"],
+    ):
+        return super().vmodel(value, *modifiers)  # type: ignore
+
+    @overload
+    def on_change(self, handler: Callable, *, key: Optional[str] = None) -> Self: ...
+
+    @overload
+    def on_change(
+        self,
+        handler: str,
+        *,
+        bindings: Optional[Dict] = None,
+        key: Optional[str] = None,
+    ) -> Self: ...
+
+    def on_change(
+        self,
+        handler: Union[Callable, str],
+        *,
+        bindings: Optional[Dict] = None,
+        key: Optional[str] = None,
+    ):
+        self.on("change", handler, bindings=bindings, key=key)  # type: ignore
+        return self
+
+    @classmethod
+    def from_list(
+        cls,
+        options: TMaybeRef[List],
+    ) -> Select:
+        with cls() as select:
+            with VFor(options) as item:
+                Select.Option(item)  # type: ignore
+
+        return select
+
+    class Option(Element):
+        def __init__(
+            self,
+            text: Optional[ui_vars.TMaybeRef[str]] = None,
+            value: Optional[ui_vars.TMaybeRef[str]] = None,
+            disabled: Optional[ui_vars.TMaybeRef[bool]] = None,
+        ):
+            props = {
+                key: value
+                for key, value in {
+                    "text": text,
+                    "value": value,
+                    "disabled": disabled,
+                }.items()
+                if value is not None
+            }
+            super().__init__("option")
+
+            self._props.update(props)

instaui/components/html/span.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Union
+from instaui.components.element import Element
+
+if TYPE_CHECKING:
+    import instaui.vars as ui_vars
+
+
+class Span(Element):
+    def __init__(
+        self,
+        text: Union[str, ui_vars.TMaybeRef[Any]],
+    ):
+        super().__init__("span")
+        self.props(
+            {
+                "innerText": text,
+            }
+        )

instaui/components/html/ul.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+from typing import List, Union
+from instaui.components.element import Element
+from .li import Li
+from instaui.components.vfor import VFor
+
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+
+
+class Ul(Element):
+    def __init__(self):
+        super().__init__("ul")
+
+    @classmethod
+    def from_list(cls, data: Union[List, ElementBindingMixin[List]]) -> Ul:
+        with Ul() as ul:
+            with VFor(data) as items:
+                Li(items)
+
+        return ul

instaui/components/match.py

@@ -0,0 +1,106 @@
+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 ElementBindingMixin
+
+
+class Match(Component):
+    def __init__(self, on: ElementBindingMixin):
+        super().__init__("match")
+        self._on = on
+        self._default_case = None
+
+    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(append_to_app=False)
+        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"] = {
+            "value": self._value,
+        }
+        props = data["props"]
+
+        props["scope"] = self.__scope
+
+        if self._slot_manager.has_slot():
+            props["items"] = self._slot_manager
+
+        data.pop("slots", None)
+        return data
+
+
+class DefaultCase(Component):
+    def __init__(self):
+        super().__init__("default-case")
+
+        self.__scope_manager = new_scope(append_to_app=False)
+        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"]
+
+        props["scope"] = self.__scope
+
+        if self._slot_manager.has_slot():
+            props["items"] = self._slot_manager
+
+        data.pop("slots", None)
+        return data

instaui/components/row.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import (
+    TypeVar,
+)
+from instaui.components.element import Element
+
+_T = TypeVar("_T")
+
+
+class Row(Element):
+    def __init__(
+        self,
+    ):
+        super().__init__("div")
+        self.style("display: flex; flex-direction: row;")
+
+
+    def gap(self, value: str) -> Row:
+        return self.style({"gap": value})

instaui/components/slot.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Union
+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.vars.slot_prop import BindingSlotPropItem
+
+if TYPE_CHECKING:
+    from instaui.components.component import Component
+    from instaui.components.vfor import VFor
+
+_DEFAULT_SLOT_NAME = ":"
+
+
+class SlotManager(Jsonable):
+    def __init__(self) -> None:
+        super().__init__()
+        self._slots: Dict[str, Slot] = {}
+
+    def get_slot(self, name: str) -> Slot:
+        name = _DEFAULT_SLOT_NAME if name == "default" else name
+
+        if name not in self._slots:
+            self._slots[name] = Slot(name)
+
+        return self._slots[name]
+
+    @property
+    def default(self):
+        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:
+        return len(self._slots) > 0
+
+
+class Slot(Jsonable):
+    def __init__(self, name: str) -> None:
+        super().__init__()
+
+        self._id: Optional[str] = None
+        self._name = name
+        self._children: List[Union[Component, VFor]] = []
+        self._props_use_name: Set[str] = set()
+
+    def _has_props_use(self):
+        return len(self._props_use_name) > 0
+
+    def props(self, name: str):
+        if self._id is None:
+            self._id = get_app_slot().generate_slot_id()
+
+        self._props_use_name.add(name)
+        return BindingSlotPropItem(self._id, name)
+
+    def __enter__(self):
+        get_slot_stacks().append(self)
+        return self
+
+    def __exit__(self, *_):
+        pop_slot()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        if self._children:
+            data["items"] = self._children
+
+        if self._props_use_name:
+            data["props"] = {"id": self._id, "use": list(self._props_use_name)}
+
+        return data

instaui/components/transition_group.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from instaui.components.element import Element
+
+
+class TransitionGroup(Element):
+    def __init__(
+        self,
+    ):
+        super().__init__("ts-group")

instaui/components/value_element.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+from typing import (
+    Generic,
+    List,
+    Optional,
+    Union,
+    TypeVar,
+)
+from instaui.components.element import Element
+from instaui import consts
+
+from instaui.vars.types import TMaybeRef
+from instaui.vars.web_computed import WebComputed
+
+
+_T = TypeVar("_T")
+
+
+class ValueElement(Element, Generic[_T]):
+    def __init__(
+        self,
+        tag: Optional[str] = None,
+        value: Union[_T, TMaybeRef[_T], None] = None,
+        is_html_component: bool = False,
+        value_name: str = "value",
+    ):
+        super().__init__(tag)
+        self.__is_html_component = is_html_component
+
+        if value is not None:
+            if isinstance(value, WebComputed):
+                self.props({value_name:value})
+            else:
+                self.vmodel(value, prop_name=value_name)
+
+    def vmodel(
+        self,
+        value,
+        modifiers: Union[consts.TModifier, List[consts.TModifier], None] = None,
+        *,
+        prop_name: str = "value",
+    ):
+        return super().vmodel(
+            value,
+            modifiers,
+            prop_name=prop_name,
+            is_html_component=self.__is_html_component,
+        )