instaui 0.1.0__py3-none-any.whl

instaui/spa_router/_route_model.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+import typing
+from pydantic import BaseModel, Field, ConfigDict, field_serializer, model_serializer
+
+from instaui.components.html.div import Div
+from instaui.runtime._app import get_app_slot, new_scope
+from instaui.components.component import Component
+from instaui.runtime.scope import Scope
+from instaui.common.jsonable import dumps2dict
+
+from . import _types
+
+
+class RouteItem(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    component_fn: typing.Optional[typing.Callable] = Field(exclude=True)
+    scope: typing.Optional[Scope] = None
+    vue_route_item: VueRouteItem = Field(serialization_alias="vueItem")
+
+    # def model_post_init(self, __context: typing.Any) -> None:
+    #     if self.component_fn is None and (not self.vue_route_item.path):
+    #         raise ValueError("Either component_fn or vue_route_item.path must be set")
+
+    #     if self.component_fn is None:
+    #         return None
+
+    #     if self.vue_route_item.path is None:
+    #         self.vue_route_item.path = f"/{'' if self.component_fn.__name__=='index' else self.component_fn.__name__}"
+
+    #     app = get_app_slot()
+
+    #     with new_scope(append_to_app=False) as scope:
+    #         with Div() as div:
+    #             self.component_fn()
+
+    #     app.items.pop()
+
+    #     self.scope = scope
+    #     self.vue_route_item.component = div._slot_manager.default._children
+
+    # @field_serializer("scope")
+    # def serialize_scope(self, value: Scope):
+    #     return dumps2dict(value)
+
+    @model_serializer
+    def model_ser(self):
+        if self.component_fn is None and (not self.vue_route_item.path):
+            raise ValueError("Either component_fn or vue_route_item.path must be set")
+
+        if self.component_fn is None:
+            return {
+                "vueItem": self.vue_route_item,
+            }
+
+        if self.vue_route_item.path is None:
+            self.vue_route_item.path = f"/{'' if self.component_fn.__name__=='index' else self.component_fn.__name__}"
+
+        app = get_app_slot()
+        with new_scope(append_to_app=False) as scope:
+            with Div() as div:
+                self.component_fn()
+
+        app.items.pop()
+
+        self.scope = scope
+        self.vue_route_item.component = div._slot_manager.default._children
+
+        return {
+            "scope": dumps2dict(scope),
+            "vueItem": self.vue_route_item,
+        }
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        component_fn: typing.Optional[typing.Callable] = None,
+        path: typing.Optional[str] = None,
+        name: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, str]] = None,
+        children: typing.Optional[typing.List[RouteItem]] = None,
+    ):
+        """Create a new RouteItem
+
+        Example:
+        .. code-block:: python
+            routes = [
+                spa_router.RouteItem.create(path='/',component_fn=home),
+                spa_router.RouteItem.create(path='/user',component_fn=user_home),
+            ]
+
+            spa_router.config_router(routes=routes)
+
+        Args:
+            component_fn (typing.Callable): function that returns a component to be rendered.
+            path (typing.Optional[str], optional): route path. Defaults to None.
+            name (typing.Optional[str], optional): route name. Defaults to None.
+            params (typing.Optional[typing.Dict[str, str]], optional): route params. Defaults to None.
+            children (typing.Optional[typing.List[RouteItem]], optional): child routes. Defaults to None.
+
+        """
+
+        return cls(
+            component_fn=component_fn,
+            vue_route_item=VueRouteItem(
+                path=path,
+                name=name,
+                params=params,
+                component=[],
+                children=children,
+            ),
+        )
+
+
+class VueRouteItem(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    path: typing.Optional[str] = None
+    params: typing.Optional[typing.Dict[str, str]] = None
+    name: typing.Optional[str] = None
+    component: typing.Optional[typing.List[Component]] = []
+    children: typing.Optional[typing.List[RouteItem]] = None
+
+    @field_serializer("component")
+    def serialize_component(self, value: typing.List[Component]):
+        if not value:
+            return []
+        return dumps2dict(value)
+
+
+class RouteCollector(BaseModel):
+    mode: _types.TRouterHistoryMode = "hash"
+    keep_alive: bool = Field(default=False, serialization_alias="kAlive")
+    routes: typing.List[RouteItem] = []
+
+    def add_route(self, item: RouteItem):
+        self.routes.append(item)
+        return self

instaui/spa_router/_router_box.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+from typing import Dict, List
+from instaui.common.jsonable import Jsonable
+from instaui.components.component import Component
+from instaui.runtime.scope import Scope
+
+from . import _types
+from ._route_model import RouteCollector
+
+
+class RouterBox_(Jsonable):
+    def __init__(self):
+        self._mode: _types.TRouterHistoryMode = "web"
+        self._keep_alive: bool = False
+        self._component_map: Dict[str, Dict] = {}
+        self._route_collector: RouteCollector = RouteCollector()
+
+    def add_component(
+        self,
+        path: str,
+        components: List[Component],
+        scope: Scope,
+        lazy_loading: bool = False,
+    ):
+        config = {"items": components, "scope": scope}
+        if lazy_loading:
+            config["lazy"] = True
+
+        self._component_map[path] = config
+
+    def _to_json_dict(self):
+        data = {}
+
+        data["routes"] = self._route_collector.model_dump(exclude_none=True)["routes"]
+        data["mode"] = self._mode
+
+        if self._keep_alive is not False:
+            data["kAlive"] = self._keep_alive
+
+        return data

instaui/spa_router/_router_output.py

@@ -0,0 +1,22 @@
+from typing import List, Optional
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.py_binding import CanOutputMixin
+from pydantic import BaseModel
+
+
+class RouterOutput(Jsonable, CanOutputMixin):
+    def __init__(self):
+        self.type = "routeAct"
+
+    def _to_output_config(self):
+        return self._to_json_dict()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        return data
+
+
+class RouterMethod(BaseModel):
+    fn: str
+    args: Optional[List]

instaui/spa_router/_router_param_var.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+import typing
+
+from instaui.common.jsonable import Jsonable
+from instaui.vars.path_var import PathVar
+
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.mixin_types.str_format_binding import StrFormatBindingMixin
+from instaui.vars.mixin_types.pathable import CanPathPropMixin
+
+
+class RouterParamsVar(
+    Jsonable,
+    PathVar,
+    ObservableMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+):
+    VAR_TYPE = "routePar"
+
+    def __init__(
+        self,
+        prop: typing.Literal["params", "path", "fullPath"] = "params",
+    ) -> None:
+        super().__init__()
+        self._prop = prop
+
+    def __to_binding_config(self):
+        return self._to_json_dict()
+
+    def _to_pathable_binding_config(self) -> typing.Dict:
+        return self.__to_binding_config()
+
+    def _to_path_prop_binding_config(self) -> typing.Dict:
+        return self.__to_binding_config()
+
+    def _to_observable_config(self):
+        return self.__to_binding_config()
+
+    def _to_element_binding_config(self):
+        return self.__to_binding_config()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        data["type"] = self.VAR_TYPE
+
+        if self._prop != "params":
+            data["prop"] = self._prop
+        return data

instaui/spa_router/_types.py

@@ -0,0 +1,4 @@
+import typing
+
+
+TRouterHistoryMode = typing.Literal["web", "memory", "hash"]

instaui/spa_router/templates/page_routes

@@ -0,0 +1,59 @@
+{% macro render_fn_arg(main_fn_name) -%}
+    {% if main_fn_name -%}
+    component_fn={{main_fn_name}},
+    {% endif -%}
+{% endmacro -%}
+
+{% macro render_children_arg(children) -%}
+    {% if children -%}
+    children=[
+        {{render_routes(children)}}],
+    {% endif -%}
+{% endmacro -%}
+
+
+{% macro render_routes(routes) -%}
+
+{% if not routes -%}
+
+{% else -%}
+    {% for route in routes -%}
+    router.RouteItem.create(
+        path="{{route.path}}", 
+        name="{{route.name}}", 
+        {{ render_fn_arg(route.main_fn_name()) |trim}}
+        {{ render_children_arg(route.children) |trim}}
+    ),
+    {% endfor -%}
+
+{% endif -%}
+
+{% endmacro -%}
+
+"""
+This file is automatically generated by InstaUI. Do not modify it manually.
+
+update: {{model.update_time}}
+"""
+
+import typing
+from instaui import spa_router as router
+
+TNames = typing.Literal{{model.route_names}}
+
+def link(text: str, name: TNames, params: typing.Optional[typing.Dict] = None):
+    return router.link.by_name(text, name=name, params=params)
+
+def get_routes():
+    try:
+        {% for code in model.get_all_main_import() -%}
+        {{code}}
+        {% endfor -%}
+
+        return [
+        {{render_routes(model.routes)}}
+    ]
+    except Exception as e:
+        print(f"router error: {e}")
+
+

instaui/static/insta-ui.css

@@ -0,0 +1 @@
+:where(body){--insta-column-gap: 1rem;height:100vh}:where(#app){height:100%}:where(*){box-sizing:border-box;margin:0;padding:0}:where(.app-box[data-v-687dcc1a],.insta-main[data-v-687dcc1a]){height:100%}:where(.insta-main[data-v-687dcc1a]){--insta-padding: 16px;padding:var(--insta-padding, 16px)}