instaui 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

instaui/runtime/_app.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Set
+from typing_extensions import Unpack, TypedDict
 from instaui.common.jsonable import Jsonable
 from .resource import HtmlResource
 from instaui.consts import _T_App_Mode
@@ -20,14 +21,16 @@ if TYPE_CHECKING:
 
 class App(Jsonable):
     _default_app_slot: ClassVar[Optional[App]] = None
+    _web_server_info: ClassVar[Optional[Dict]] = None
 
-    def __init__(self, *, mode: _T_App_Mode) -> None:
+    def __init__(self, *, mode: _T_App_Mode, meta: Optional[Dict] = None) -> None:
         super().__init__()
         self._scope_id_counter = 0
         self._vfor_id_counter = 0
         self._slot_id_counter = 0
         self.mode: _T_App_Mode = mode
         self.items: List[Component] = []
+        self.meta = meta
         self._slots_stacks: List[Slot] = []
 
         defalut_scope = self.create_scope()
@@ -35,6 +38,7 @@ class App(Jsonable):
         self._scopes: List[Scope] = [defalut_scope]
         self._html_resource = HtmlResource()
         self._component_dependencies: Set[ComponentDependencyInfo] = set()
+        self._temp_component_dependencies: Dict[str, ComponentDependencyInfo] = {}
         self._plugin_dependencies: Set[PluginDependencyInfo] = set()
 
         self._page_path: Optional[str] = None
@@ -71,6 +75,17 @@ class App(Jsonable):
     def reset_html_resource(self):
         self._html_resource = HtmlResource()
 
+    def add_temp_component_dependency(self, dependency: ComponentDependencyInfo):
+        self._temp_component_dependencies[dependency.tag_name] = dependency
+
+    def get_temp_component_dependency(
+        self, tag_name: str, default: ComponentDependencyInfo
+    ) -> ComponentDependencyInfo:
+        return self._temp_component_dependencies.get(tag_name, default)
+
+    def has_temp_component_dependency(self, tag_name: str):
+        return tag_name in self._temp_component_dependencies
+
     def use_component_dependency(
         self, dependency: ComponentDependencyInfo, *, replace=False
     ) -> None:
@@ -109,6 +124,9 @@ class App(Jsonable):
                 exclude_defaults=True, by_alias=True
             )
 
+        if self._web_server_info is not None:
+            data["webInfo"] = self._web_server_info
+
         return data
 
     @classmethod
@@ -181,8 +199,8 @@ def pop_slot():
     get_slot_stacks().pop()
 
 
-def new_app_slot(mode: _T_App_Mode):
-    return _app_var.set(App(mode=mode))
+def new_app_slot(mode: _T_App_Mode, app_meta: Optional[Dict] = None):
+    return _app_var.set(App(mode=mode, meta=app_meta))
 
 
 def reset_app_slot(token: Token[App]):
@@ -198,3 +216,19 @@ def check_default_app_slot_or_error(
 ):
     if isinstance(get_app_slot(), DefaultApp):
         raise ValueError(error_message)
+
+
+class TWebServerInfo(TypedDict, total=False):
+    watch_url: Optional[str]
+    watch_async_url: Optional[str]
+    event_url: Optional[str]
+    event_async_url: Optional[str]
+
+
+def update_web_server_info(**kwargs: Unpack[TWebServerInfo]):
+    if App._web_server_info is None:
+        App._web_server_info = {}
+
+    data = {k: v for k, v in kwargs.items() if v is not None}
+
+    App._web_server_info.update(data)

instaui/runtime/_link_manager.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+from typing import (
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    TypeVar,
+    Hashable,
+)
+
+_TLinkActionObj = TypeVar("_TLinkActionObj")
+
+_DEFAULT_KEY_FN = lambda x: x  # noqa: E731
+
+
+class LinkManager(Generic[_TLinkActionObj]):
+    def __init__(
+        self, key_fn: Optional[Callable[[_TLinkActionObj], Hashable]] = None
+    ) -> None:
+        self._key_fn = key_fn or _DEFAULT_KEY_FN
+        self._actions_map: Dict[
+            Tuple[Literal["add", "remove"], Hashable], _TLinkActionObj
+        ] = {}
+
+    def add_link(
+        self,
+        obj: _TLinkActionObj,
+    ):
+        key = ("add", self._key_fn(obj))
+        self._actions_map[key] = obj
+
+    def remove_link(
+        self,
+        obj: _TLinkActionObj,
+    ):
+        key = ("remove", self._key_fn(obj))
+        self._actions_map[key] = obj
+
+    def get_valid_links(
+        self, secondary_manager: Optional[LinkManager] = None
+    ) -> List[_TLinkActionObj]:
+        secondary_maps = secondary_manager._actions_map if secondary_manager else {}
+        merger_map = {**secondary_maps, **self._actions_map}
+
+        result = {}
+
+        for (action, key), obj in merger_map.items():
+            if action == "add":
+                result[key] = obj
+                continue
+
+            if key in result:
+                del result[key]
+
+        return list(result.values())
+
+
+if __name__ == "__main__":
+
+    def test_baes():
+        manager: LinkManager[str] = LinkManager()
+        manager.add_link("a")
+        manager.add_link("b")
+        manager.add_link("c")
+        manager.remove_link("b")
+
+        assert manager.get_valid_links() == ["a", "c"]
+
+    test_baes()
+
+    def test_with_other():
+        other: LinkManager[str] = LinkManager()
+        other.add_link("a")
+        other.add_link("b")
+        other.add_link("c")
+
+        manager1: LinkManager[str] = LinkManager()
+        manager1.add_link("b")
+        manager1.add_link("d")
+        manager1.add_link("e")
+        manager1.remove_link("a")
+        manager1.remove_link("b")
+
+        assert manager1.get_valid_links(other) == ["c", "d", "e"]
+
+    test_with_other()

instaui/runtime/resource.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, Union
 from .dataclass import JsLink, VueAppUse, VueAppComponent
+from ._link_manager import LinkManager
 
 
 class HtmlResource:
@@ -10,9 +11,11 @@ class HtmlResource:
     favicon: Optional[Path] = None
 
     def __init__(self) -> None:
-        self._css_links: Dict[Union[str, Path], Any] = {}
+        self._css_links_manager: LinkManager[Union[str, Path]] = LinkManager()
         self._style_tags: List[str] = []
-        self._js_links: List[JsLink] = []
+        self._js_links_manager: LinkManager[JsLink] = LinkManager(
+            key_fn=lambda js_link: js_link.link
+        )
         self._script_tags: List[str] = []
         self._vue_app_use: Set[VueAppUse] = set()
         self._vue_app_components: Set[VueAppComponent] = set()
@@ -20,10 +23,10 @@ class HtmlResource:
         self._appConfig = "{}"
 
     def add_css_link(self, link: Union[str, Path]):
-        self._css_links[link] = None
+        self._css_links_manager.add_link(link)
 
     def remove_css_link(self, link: Union[str, Path]):
-        self._css_links.pop(link, None)
+        self._css_links_manager.remove_link(link)
 
     def add_style_tag(self, content: str):
         self._style_tags.append(content)
@@ -33,12 +36,19 @@ class HtmlResource:
         link: Union[str, Path],
         *,
         attrs: Optional[Dict[str, Any]] = None,
-        insert_before: int = -1,
     ):
-        if insert_before == -1:
-            self._js_links.append(JsLink(link, attrs or {}))
-            return
-        self._js_links.insert(insert_before, JsLink(link, attrs or {}))
+        self._js_links_manager.add_link(JsLink(link, attrs or {}))
+
+    def remove_js_link(self, link: Union[str, Path]):
+        self._js_links_manager.remove_link(JsLink(link))
+
+    def get_valid_js_links(self, default_js_links_manager: LinkManager) -> List[JsLink]:
+        return self._js_links_manager.get_valid_links(default_js_links_manager)
+
+    def get_valid_css_links(
+        self, default_css_links_manager: LinkManager[Union[str, Path]]
+    ) -> List[Union[str, Path]]:
+        return self._css_links_manager.get_valid_links(default_css_links_manager)
 
     def add_script_tag(
         self, content: str, script_attrs: Optional[Dict[str, Any]] = None

instaui/runtime/scope.py

@@ -8,6 +8,9 @@ if TYPE_CHECKING:
     from instaui.vars.mixin_types.var_type import VarMixin
     from instaui.vars.mixin_types.py_binding import CanInputMixin
     from instaui.vars.web_computed import WebComputed
+    from instaui.vars.js_computed import JsComputed
+    from instaui.vars.vue_computed import VueComputed
+    from instaui.vars.data import ConstData
     from instaui.watch.web_watch import WebWatch
     from instaui.watch.js_watch import JsWatch
     from instaui.watch.vue_watch import VueWatch
@@ -20,7 +23,10 @@ class Scope(Jsonable):
         self.id = id
         self._vars_id_counter = 0
         self._element_ref_id_counter = 0
-        self._vars: List[VarMixin] = []
+        self._refs: List[VarMixin] = []
+        self._const_data: List[ConstData] = []
+        self._js_computeds: List[JsComputed] = []
+        self._vue_computeds: List[VueComputed] = []
         self._web_computeds: List[WebComputed] = []
         self._element_refs: List[ElementRef] = []
         self._run_method_records: List = []
@@ -52,8 +58,17 @@ class Scope(Jsonable):
             "on": [v._to_input_config() for v in on],
         }
 
-    def register_var(self, var: VarMixin) -> None:
-        self._vars.append(var)
+    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)
@@ -69,8 +84,8 @@ class Scope(Jsonable):
 
     def _to_json_dict(self):
         data = super()._to_json_dict()
-        if self._vars:
-            data["vars"] = self._vars
+        if self._refs:
+            data["refs"] = self._refs
         if self._query:
             data["query"] = self._query
         if self._web_watchs:
@@ -83,6 +98,12 @@ class Scope(Jsonable):
             data["eRefs"] = self._element_refs
         if self._web_computeds:
             data["web_computed"] = self._web_computeds
+        if self._js_computeds:
+            data["js_computed"] = self._js_computeds
+        if self._vue_computeds:
+            data["vue_computed"] = self._vue_computeds
+        if self._const_data:
+            data["data"] = self._const_data
 
         return data
 
@@ -91,8 +112,8 @@ class GlobalScope(Scope):
     def __init__(self, id: str) -> None:
         super().__init__(id)
 
-    def register_var(self, var: VarMixin) -> None:
-        raise ValueError("Can not register vars in global scope")
+    def register_ref(self, var: VarMixin) -> None:
+        raise ValueError("Can not register ref in global scope")
 
     def register_web_computed(self, computed: WebComputed) -> None:
         raise ValueError("Can not register web_computeds  in global scope")

instaui/shadcn_classless/_index.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+from instaui.runtime._app import get_app_slot
+
+
+_STATIC_DIR = Path(__file__).parent / "static"
+_CSS_FILE = _STATIC_DIR / "shadcn-classless.css"
+
+
+def use_shadcn_classless(value=True):
+    """Use shadcn-classless.css or not.
+
+    Args:
+        value (bool, optional): Whether to use shadcn-classless.css or not. Defaults to True.
+
+    Example:
+
+    App default use shadcn-classless.css:
+    .. code-block:: python
+
+        @ui.page('/')
+        def index():
+
+            # Create a container with shadcn-classless class
+            with html.div().classes("shadcn-classless"):
+                html.h1("Hello, world!")
+
+                with html.form():
+                    html.input()
+                    html.button("Submit")
+
+    Can be disabled:
+    .. code-block:: python
+        # App does not use shadcn-classless
+        ui.use_shadcn_classless(False)
+
+    """
+
+    if value:
+        get_app_slot()._html_resource.add_css_link(_CSS_FILE)
+
+    else:
+        get_app_slot()._html_resource.remove_css_link(_CSS_FILE)