instaui 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

instaui/html_tools.py

@@ -1,50 +1,39 @@
 from __future__ import annotations
 from pathlib import Path
-from typing import Dict, Literal, Optional, Union
-import instaui.consts as consts
+from typing import Any, Dict, Literal, Optional, Union
 from instaui.common.jsonable import dumps, dumps2dict
-from instaui.runtime import get_app_slot, HtmlResource
-from instaui.template import render_zero_html
+from instaui.runtime._app import get_app_slot
 
 
-def add_css_link(href: Union[str, Path], *, shared: bool = False):
-    if shared:
-        HtmlResource.default_css_link(href)
-
+def add_css_link(href: Union[str, Path]):
     get_app_slot()._html_resource.add_css_link(href)
 
 
 def add_js_link(
     link: Union[str, Path],
     *,
-    shared: bool = False,
-    type: Optional[Literal["module", "importmap"]] = None,
+    type: Optional[Literal["module"]] = None,
 ):
     attrs = {
         "type": type,
     }
 
-    if shared:
-        HtmlResource.default_js_link(link, attrs=attrs)
-
     get_app_slot()._html_resource.add_js_link(link, attrs=attrs)
 
 
-def add_style(content: str, *, shared: bool = False):
-    if shared:
-        HtmlResource.default_style_tag(content)
+def add_style(content: str):
     get_app_slot()._html_resource.add_style_tag(content)
 
 
-def add_js_code(code: str, *, shared: bool = False):
-    if shared:
-        HtmlResource.default_script_tag(code)
-    get_app_slot()._html_resource.add_script_tag(code)
+def use_tailwind(value=True):
+    get_app_slot()._html_resource.use_tailwind = value
+
+
+def add_js_code(code: str, *, script_attrs: Optional[Dict[str, Any]] = None):
+    get_app_slot()._html_resource.add_script_tag(code, script_attrs=script_attrs)
 
 
-def add_vue_app_use(name: str, *, shared: bool = False):
-    if shared:
-        HtmlResource.default_vue_app_use(name)
+def add_vue_app_use(name: str):
     get_app_slot()._html_resource.add_vue_app_use(name)
 
 
@@ -54,86 +43,3 @@ def to_config_data() -> Dict:
 
 def to_json(indent=False):
     return dumps(get_app_slot(), indent=indent)
-
-
-def to_html(file: Union[str, Path]):
-    if isinstance(file, str):
-        import inspect
-
-        frame = inspect.currentframe().f_back  # type: ignore
-        assert frame is not None
-        script_file = inspect.getfile(frame)
-        file = Path(script_file).parent.joinpath(file)
-
-    file = Path(file)
-    system_slot = get_app_slot()
-    html_resource = system_slot._html_resource
-
-    if html_resource.use_tailwind:
-        html_resource.add_js_link(consts.TAILWIND_JS_PATH, insert_before=0)
-    html_resource.add_js_link(consts.APP_IIFE_JS_PATH, insert_before=0)
-    html_resource.add_js_link(consts.VUE_IIFE_JS_PATH, insert_before=0)
-    html_resource.add_css_link(consts.APP_CSS_PATH)
-
-    # register custom components
-    for component in system_slot._js_components:
-        if not component.iife:
-            continue
-
-        html_resource.add_js_link(component.iife)
-
-        if component.css:
-            for css_link in component.css:
-                html_resource.add_css_link(css_link)
-
-        html_resource.add_vue_app_use(component.name)
-
-    for plugin in system_slot._plugins:
-        if not plugin.iife:
-            continue
-
-        html_resource.add_js_link(plugin.iife)
-
-        if plugin.css:
-            for css_link in plugin.css:
-                html_resource.add_css_link(css_link)
-
-        html_resource.add_vue_app_use(plugin.name)
-
-    _css_file_link_to_style_code(html_resource)
-    _js_file_link_to_script_code(html_resource)
-
-    raw = render_zero_html(to_json())
-    file.write_text(raw, "utf8")
-
-    return file.resolve().absolute()
-
-
-def _css_file_link_to_style_code(html_resource: HtmlResource):
-    files = [link for link in html_resource._css_links.keys() if isinstance(link, Path)]
-
-    for file in files:
-        content = file.read_text(encoding="utf-8")
-        html_resource.add_style_tag(content)
-
-    # remove file links
-    html_resource._css_links = {
-        link: None
-        for link in html_resource._css_links.keys()
-        if not isinstance(link, Path)
-    }
-
-
-def _js_file_link_to_script_code(html_resource: HtmlResource):
-    files = (
-        info.link for info in html_resource._js_links if isinstance(info.link, Path)
-    )
-
-    for file in files:
-        content = file.read_text(encoding="utf-8")
-        html_resource.add_script_tag(content)
-
-    # remove file links
-    html_resource._js_links = [
-        info for info in html_resource._js_links if not isinstance(info.link, Path)
-    ]

instaui/page_info.py

@@ -1,23 +1,13 @@
 from __future__ import annotations
-from typing import Callable, Optional, TYPE_CHECKING
+from typing import Callable
 from dataclasses import dataclass
 from urllib.parse import quote
 
 
-if TYPE_CHECKING:
-    from instaui.runtime.resource import HtmlResource
-
-
 @dataclass
 class PageInfo:
     path: str
     func: Callable
-    page_loading: Optional[Callable] = None
-    use_tailwind: Optional[bool] = None
 
     def create_key(self) -> str:
         return quote(self.path)
-
-    def apply_settings(self, html_resource: HtmlResource):
-        if self.use_tailwind is not None:
-            html_resource.use_tailwind = self.use_tailwind

instaui/runtime/_app.py

@@ -5,7 +5,6 @@ from instaui.common.jsonable import Jsonable
 from .resource import HtmlResource
 from instaui.consts import _T_App_Mode
 from contextvars import ContextVar, Token
-from copy import copy
 from contextlib import contextmanager
 from instaui.runtime.scope import Scope, GlobalScope
 from types import MappingProxyType
@@ -13,14 +12,14 @@ from types import MappingProxyType
 if TYPE_CHECKING:
     from instaui.components.component import Component
     from instaui.components.slot import Slot
-    from instaui.dependencies import ComponentRegistrationInfo, PluginRegistrationInfo
+
+    from instaui.dependencies.component_dependency import ComponentDependencyInfo
+    from instaui.dependencies.plugin_dependency import PluginDependencyInfo
     from instaui.spa_router._route_model import RouteCollector
 
 
 class App(Jsonable):
     _default_app_slot: ClassVar[Optional[App]] = None
-    _default_js_components: ClassVar[Set[ComponentRegistrationInfo]] = set()
-    _default_plugins: ClassVar[Set[PluginRegistrationInfo]] = set()
 
     def __init__(self, *, mode: _T_App_Mode) -> None:
         super().__init__()
@@ -35,11 +34,9 @@ class App(Jsonable):
         self._scope_stack: List[Scope] = [defalut_scope]
         self._scopes: List[Scope] = [defalut_scope]
         self._html_resource = HtmlResource()
-        self._js_components: Set[ComponentRegistrationInfo] = copy(
-            self._default_js_components
-        )
+        self._component_dependencies: Set[ComponentDependencyInfo] = set()
+        self._plugin_dependencies: Set[PluginDependencyInfo] = set()
 
-        self._plugins: Set[PluginRegistrationInfo] = copy(self._default_plugins)
         self._page_path: Optional[str] = None
         self._page_params: Dict[str, Any] = {}
         self._query_params: Dict[str, Any] = {}
@@ -74,11 +71,11 @@ class App(Jsonable):
     def reset_html_resource(self):
         self._html_resource = HtmlResource()
 
-    def register_component(self, component: ComponentRegistrationInfo) -> None:
-        self._js_components.add(component)
+    def use_component_dependency(self, dependency: ComponentDependencyInfo) -> None:
+        self._component_dependencies.add(dependency)
 
-    def register_plugin(self, plugin: PluginRegistrationInfo) -> None:
-        self._plugins.add(plugin)
+    def use_plugin_dependency(self, dependency: PluginDependencyInfo) -> None:
+        self._plugin_dependencies.add(dependency)
 
     def register_router(self, collector: RouteCollector) -> None:
         self._route_collector = collector
@@ -115,14 +112,6 @@ class App(Jsonable):
             cls._default_app_slot = DefaultApp(mode="web")
         return cls._default_app_slot
 
-    @classmethod
-    def default_js_components(cls, component: ComponentRegistrationInfo):
-        cls._default_js_components.add(component)
-
-    @classmethod
-    def default_plugins(cls, plugin: PluginRegistrationInfo):
-        cls._default_plugins.add(plugin)
-
 
 class DefaultApp(App):
     _instance = None

instaui/runtime/resource.py

@@ -1,28 +1,20 @@
 from __future__ import annotations
 from pathlib import Path
-from typing import Any, ClassVar, Dict, List, Optional, Set, Union
+from typing import Any, Dict, List, Optional, Set, Union
 from .dataclass import JsLink, VueAppUse, VueAppComponent
 
 
 class HtmlResource:
-    _default_css_links: ClassVar[Dict[Union[str, Path], Any]] = {}
-    _default_style_tags: ClassVar[List[str]] = []
-    _default_js_links: ClassVar[List[JsLink]] = []
-    _default_script_tags: ClassVar[List[str]] = []
-    _default_vue_app_use: ClassVar[Set[VueAppUse]] = set()
-    _default_vue_app_components: ClassVar[Set[VueAppComponent]] = set()
-    use_tailwind: bool = False
+    use_tailwind: Optional[bool] = None
     _title: str = ""
 
     def __init__(self) -> None:
-        self._css_links: Dict[Union[str, Path], Any] = self._default_css_links.copy()
-        self._style_tags: List[str] = self._default_style_tags.copy()
-        self._js_links: List[JsLink] = self._default_js_links.copy()
-        self._script_tags: List[str] = self._default_script_tags.copy()
-        self._vue_app_use: Set[VueAppUse] = self._default_vue_app_use.copy()
-        self._vue_app_components: Set[VueAppComponent] = (
-            self._default_vue_app_components.copy()
-        )
+        self._css_links: Dict[Union[str, Path], Any] = {}
+        self._style_tags: List[str] = []
+        self._js_links: List[JsLink] = []
+        self._script_tags: List[str] = []
+        self._vue_app_use: Set[VueAppUse] = set()
+        self._vue_app_components: Set[VueAppComponent] = set()
         self._import_maps: Dict[str, str] = {}
         self.title: str = self._title
         self._appConfig = "{}"
@@ -45,7 +37,9 @@ class HtmlResource:
             return
         self._js_links.insert(insert_before, JsLink(link, attrs or {}))
 
-    def add_script_tag(self, content: str):
+    def add_script_tag(
+        self, content: str, script_attrs: Optional[Dict[str, Any]] = None
+    ):
         self._script_tags.append(content)
 
     def add_vue_app_use(self, name: str):
@@ -56,32 +50,3 @@ class HtmlResource:
 
     def add_import_map(self, name: str, link: str):
         self._import_maps[name] = link
-
-    @classmethod
-    def default_css_link(cls, link: Union[str, Path]):
-        cls._default_css_links[link] = None
-
-    @classmethod
-    def default_style_tag(cls, content: str):
-        cls._default_style_tags.append(content)
-
-    @classmethod
-    def default_js_link(
-        cls,
-        link: Union[str, Path],
-        *,
-        attrs: Optional[Dict[str, Any]] = None,
-        insert_before: int = -1,
-    ):
-        if insert_before == -1:
-            cls._default_js_links.append(JsLink(link, attrs or {}))
-            return
-        cls._default_js_links.insert(insert_before, JsLink(link, attrs or {}))
-
-    @classmethod
-    def default_script_tag(cls, content: str):
-        cls._default_script_tags.append(content)
-
-    @classmethod
-    def default_vue_app_use(cls, name: str):
-        cls._default_vue_app_use.add(VueAppUse(name))

instaui/spa_router/_file_base_utils.py

@@ -3,7 +3,6 @@ from collections import deque
 from datetime import datetime
 import importlib.util
 from pathlib import Path
-import sys
 import typing
 from pydantic import BaseModel, Field
 import jinja2
@@ -13,29 +12,42 @@ import inspect
 def build_routes_from_files(
     folder_path: typing.Union[str, Path] = "pages",
     module_name: str = "_routes",
+    route_config_var_name: str = "_route_config",
 ):
-    folder_path = _utils.get_caller_path().parent / Path(folder_path)
-    root = _model_utils.create_root(folder_path, module_name)
+    global_args = _GlobalArgs(
+        base_folder_path=_utils.get_caller_path().parent / Path(folder_path),
+        module_name=module_name,
+        route_config_var_name=route_config_var_name,
+    )
+
+    root = _model_utils.create_root(global_args)
     _code_gen.generate_router_file(root)
 
-    print(f"Build _routes from files in {folder_path}...")
-    # _module_utils.reload_module_from_folder(folder_path, module_name)
+    print(f"Build _routes from files in {global_args.base_folder_path}...")
+
+
+class _GlobalArgs(BaseModel):
+    base_folder_path: Path
+    module_name: str
+    route_config_var_name: str
 
 
 class _model_utils:
     class FileRouteInfo(BaseModel):
         file: Path
         base_folder: Path
+        global_args: _GlobalArgs
         children: typing.List[_model_utils.FileRouteInfo] = []
-
         path: str = Field(init=False, default="")
         name: str = Field(init=False, default="")
         fn_path: typing.Optional[str] = Field(init=False, default=None)
 
         params: str = Field(init=False, default="")
+        meta: typing.Dict = Field(init=False, default={})
 
         def model_post_init(self, __context) -> None:
             self.params = self._extract_params()
+            self.meta = self._extract_meta()
             self.path, self.name = self._extra_path_name()
 
             if self.file.is_file():
@@ -46,14 +58,15 @@ class _model_utils:
         def is_index_file(self):
             return self.file.is_file() and self.file.stem == "index"
 
-        def change_index(self, index_info: _model_utils.FileRouteInfo):
+        def change_sync_index_info(self, index_info: _model_utils.FileRouteInfo):
             self.fn_path = index_info.fn_path
             self.path = self.path + index_info.params
+            self.meta = index_info.meta
 
         def _extract_params(self):
             if self.file.is_file():
                 route_config = _module_utils.get_module_getter(self.file)(
-                    "_route_config"
+                    self.global_args.route_config_var_name
                 )
                 if route_config:
                     if "params" in route_config:
@@ -61,6 +74,18 @@ class _model_utils:
 
             return ""
 
+        def _extract_meta(self):
+            if self.file.is_file():
+                route_config = _module_utils.get_module_getter(self.file)(
+                    self.global_args.route_config_var_name
+                )
+
+                if route_config:
+                    if "meta" in route_config:
+                        return route_config["meta"]
+
+            return {}
+
         def _extra_path_name(self):
             name_parts = list(
                 self.file.relative_to(self.base_folder).with_suffix("").parts
@@ -86,12 +111,12 @@ class _model_utils:
             if not self.fn_path:
                 return ""
 
-            return f"from .{self.fn_path} import main as {self.main_fn_name()}"
+            return f"from .{self.fn_path.replace(' ','_')} import main as {self.main_fn_name()}"
 
         def main_fn_name(self):
             if not self.fn_path:
                 return ""
-            return self.name.replace(".", "_")
+            return self.name.replace(".", "_").replace(" ", "_")
 
     class FileRouteRoot(BaseModel):
         folder: str
@@ -99,15 +124,17 @@ class _model_utils:
         infos: list[_model_utils.FileRouteInfo] = []
 
     @staticmethod
-    def create_root(folder: Path, module_name: str) -> FileRouteRoot:
-        base_folder = Path(folder)
-        infos = _model_utils._create_route_info(base_folder)
+    def create_root(global_args: _GlobalArgs) -> FileRouteRoot:
+        base_folder = Path(global_args.base_folder_path)
+        infos = _model_utils._create_route_info(base_folder, global_args)
         return _model_utils.FileRouteRoot(
-            folder=str(base_folder), module_name=module_name, infos=infos
+            folder=str(base_folder), module_name=global_args.module_name, infos=infos
         )
 
     @staticmethod
-    def _create_route_info(base_folder: Path) -> typing.List[FileRouteInfo]:
+    def _create_route_info(
+        base_folder: Path, global_args: _GlobalArgs
+    ) -> typing.List[FileRouteInfo]:
         result: typing.List[_model_utils.FileRouteInfo] = []
 
         stack: deque[
@@ -124,7 +151,7 @@ class _model_utils:
 
             if is_dir:
                 folder_info = _model_utils.FileRouteInfo(
-                    file=item, base_folder=base_folder
+                    file=item, base_folder=base_folder, global_args=global_args
                 )
                 infos = ((folder_info, path) for path in item.iterdir())
                 stack.extendleft(infos)
@@ -138,13 +165,15 @@ class _model_utils:
             if item.suffix != ".py":
                 continue
 
-            file_info = _model_utils.FileRouteInfo(file=item, base_folder=base_folder)
+            file_info = _model_utils.FileRouteInfo(
+                file=item, base_folder=base_folder, global_args=global_args
+            )
 
             if parent_info is None:
                 result.append(file_info)
             else:
                 if file_info.is_index_file():
-                    parent_info.change_index(file_info)
+                    parent_info.change_sync_index_info(file_info)
 
                 else:
                     parent_info.children.append(file_info)
@@ -200,30 +229,6 @@ class _code_gen:
 
 
 class _module_utils:
-    @staticmethod
-    def reload_module_from_folder(folder: Path, module_name: str):
-        module_file_path = folder / f"{module_name}.py"
-
-        if not module_file_path.exists():
-            raise FileNotFoundError(f"No such file: '{module_file_path}'")
-
-        package_name = module_file_path.parent.name
-        spec = importlib.util.spec_from_file_location(
-            module_name, str(module_file_path)
-        )
-        if spec is None:
-            raise ImportError(f"Failed to load module: '{module_name}'")
-
-        module = importlib.util.module_from_spec(spec)
-        module.__package__ = package_name
-
-        if module_name in sys.modules:
-            sys.modules[module_name] = module
-            importlib.reload(module)
-            return
-
-        spec.loader.exec_module(module)  # type: ignore
-
     @staticmethod
     def get_module_getter(path: Path):
         if not isinstance(path, Path):

instaui/spa_router/_route_model.py

@@ -17,31 +17,7 @@ class RouteItem(BaseModel):
     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)
+    meta: typing.Optional[typing.Dict] = None
 
     @model_serializer
     def model_ser(self):
@@ -80,6 +56,7 @@ class RouteItem(BaseModel):
         name: typing.Optional[str] = None,
         params: typing.Optional[typing.Dict[str, str]] = None,
         children: typing.Optional[typing.List[RouteItem]] = None,
+        meta: typing.Optional[typing.Dict] = None,
     ):
         """Create a new RouteItem
 
@@ -103,6 +80,7 @@ class RouteItem(BaseModel):
 
         return cls(
             component_fn=component_fn,
+            meta=meta,
             vue_route_item=VueRouteItem(
                 path=path,
                 name=name,

instaui/spa_router/templates/page_routes

@@ -21,6 +21,7 @@
     router.RouteItem.create(
         path="{{route.path}}", 
         name="{{route.name}}", 
+        meta = {{route.meta}},
         {{ render_fn_arg(route.main_fn_name()) |trim}}
         {{ render_children_arg(route.children) |trim}}
     ),