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

instaui/components/component.py

@@ -22,7 +22,7 @@ class Component(Jsonable):
 
         self.tag = (
             "div"
-            if tag is None
+            if tag is None or tag == ""
             else (
                 tag._to_element_binding_config()
                 if isinstance(tag, ElementBindingMixin)

instaui/components/element.py

@@ -13,6 +13,7 @@ from typing import (
     Optional,
     Tuple,
     Union,
+    cast,
     overload,
     TYPE_CHECKING,
 )
@@ -21,11 +22,11 @@ from collections import defaultdict
 from instaui.runtime._app import get_app_slot
 from instaui.runtime._app import get_current_scope
 from instaui.vars.element_ref import ElementRef
-
-
 from instaui.vars.vfor_item import VForItem
 from instaui.components.directive import Directive
-from instaui.dependencies import ComponentRegistrationInfo, register_component
+from instaui.dependencies.component_dependency import (
+    ComponentDependencyInfo,
+)
 from .slot import SlotManager, Slot
 from instaui import consts
 from instaui.components.component import Component
@@ -69,14 +70,14 @@ PROPS_PATTERN = re.compile(
 
 
 class Element(Component):
-    component: ClassVar[Optional[ComponentRegistrationInfo]] = None
+    dependency: ClassVar[Optional[ComponentDependencyInfo]] = None
     _default_props: ClassVar[Dict[str, Any]] = {}
     _default_classes: ClassVar[List[str]] = []
     _default_style: ClassVar[Dict[str, str]] = {}
 
     def __init__(self, tag: Optional[Union[str, ElementBindingMixin]] = None):
-        if self.component:
-            tag = self.component.name
+        if self.dependency:
+            tag = self.dependency.tag_name or ""
 
         super().__init__(tag)
 
@@ -101,19 +102,28 @@ class Element(Component):
     def __init_subclass__(
         cls,
         *,
-        component: Union[str, Path, None] = None,
+        esm: Union[str, Path, None] = None,
+        externals: Optional[List[Union[str, Path]]] = None,
+        css: Union[List[Union[str, Path]], None] = None,
     ) -> None:
         super().__init_subclass__()
 
-        if component:
-            if isinstance(component, str):
-                component = Path(component)
-                if not component.is_absolute():
-                    component = Path(inspect.getfile(cls)).parent / component
+        if esm:
+            esm = _make_dependency_path(esm, cls)
+
+            if externals:
+                externals = [_make_dependency_path(e, cls) for e in externals]
+
+            if css:
+                css = [_make_dependency_path(c, cls) for c in css]
 
-            # TODO: Lazy load component registration
-            cls.component = register_component(
-                component.stem, esm=component, shared=True
+            tag_name = f"instaui-{esm.stem}"
+
+            cls.dependency = ComponentDependencyInfo(
+                tag_name=tag_name,
+                esm=esm,
+                externals=cast(List[Path], externals or []),
+                css=cast(List[Path], css or []),
             )
 
         cls._default_props = copy(cls._default_props)
@@ -365,8 +375,8 @@ class Element(Component):
         if self._directives:
             data["dir"] = list(self._directives.keys())
 
-        if self.component:
-            get_app_slot().register_component(self.component)
+        if self.dependency:
+            get_app_slot().use_component_dependency(self.dependency)
 
         if self._element_ref:
             scope = get_current_scope()
@@ -460,3 +470,13 @@ def _classifyBindableDict(
             value_data[key] = value
 
     return value_data, bind_data
+
+
+def _make_dependency_path(path: Union[str, Path], cls: type):
+    if isinstance(path, str):
+        path = Path(path)
+
+    if not path.is_absolute():
+        path = Path(inspect.getfile(cls)).parent / path
+
+    return path

instaui/components/html/checkbox.py

@@ -31,12 +31,5 @@ class Checkbox(InputEventMixin, ValueElement[Union[bool, str]]):
         if model_value is not None:
             self.props({"value": model_value})
 
-    # def vmodel(
-    #     self,
-    #     value: Any,
-    #     *modifiers: Literal["trim"] | Literal["number"] | Literal["lazy"],
-    # ):
-    #     return super().vmodel(value, *modifiers)  # type: ignore
-
     def _input_event_mixin_element(self) -> Element:
         return self

instaui/components/vfor.py

@@ -60,7 +60,7 @@ class VFor(Component, Generic[_T]):
     def __enter__(self) -> _T:
         self.__scope = self.__scope_manager.__enter__()
         super().__enter__()
-        return VForItem(self).proxy
+        return VForItem(self).proxy # type: ignore
 
     def __exit__(self, *_) -> None:
         self.__scope_manager.__exit__(*_)

instaui/dependencies/component_dependency.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+_TTagName = str
+
+
+@dataclass(frozen=True)
+class ComponentDependencyInfo:
+    tag_name: _TTagName = field(hash=True)
+    esm: Path = field(hash=False)
+    externals: Optional[List[Path]] = field(
+        default_factory=list, compare=False, hash=False
+    )
+    css: List[Path] = field(default_factory=list, compare=False, hash=False)

instaui/dependencies/plugin_dependency.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+from instaui.runtime._app import get_app_slot
+
+
+@dataclass(frozen=True)
+class PluginDependencyInfo:
+    name: str = field(hash=True)
+    esm: Path = field(hash=False)
+    externals: Optional[List[Path]] = field(
+        default_factory=list, compare=False, hash=False
+    )
+    css: List[Path] = field(default_factory=list, compare=False, hash=False)
+
+
+def register_plugin(
+    name: str,
+    esm: Path,
+    *,
+    externals: Optional[List[Path]] = None,
+    css: Optional[List[Path]] = None,
+):
+    info = PluginDependencyInfo(f"plugin/{name}", esm, externals or [], css or [])
+
+    get_app_slot().use_plugin_dependency(info)
+    return info

instaui/fastapi_server/debug_mode_router.py

@@ -24,7 +24,6 @@ async def event_generator(
     task_event = asyncio.Event()
     _task_events[connection_id] = task_event
 
-    # yield "event: task\ndata: 0 \n\n\n"
     try:
         while not task_event.is_set():
             if await request.is_disconnected():

instaui/fastapi_server/dependency_router.py

@@ -0,0 +1,21 @@
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+
+from instaui.fastapi_server import resource
+
+
+URL = f"{resource.URL}/{{hash_part:path}}"
+
+
+def create_router(app: FastAPI):
+    _dependency_handler(app)
+
+
+def _dependency_handler(app: FastAPI):
+    @app.get(URL)
+    def _(hash_part: str) -> FileResponse:
+        local_file = resource.get_by_hash(hash_part)
+
+        return FileResponse(
+            local_file, headers={"Cache-Control": "public, max-age=3600"}
+        )

instaui/fastapi_server/resource.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+from typing import Dict
+from urllib.parse import quote as urllib_quote
+from instaui.systems import file_system
+from instaui.version import __version__ as _INSTA_VERSION
+
+URL = f"/_instaui_{_INSTA_VERSION}/resource"
+_THashPart = str
+_HASH_PART_MAP: Dict[_THashPart, Path] = {}
+_FILE_URL_MAP: Dict[Path, _THashPart] = {}
+
+
+def get_by_hash(hash_part: str) -> Path:
+    return _HASH_PART_MAP[hash_part]
+
+
+def record_resource(path: Path):
+    if path in _FILE_URL_MAP:
+        return _FILE_URL_MAP[path]
+
+    hash_part = _generate_hash_part(path)
+    _HASH_PART_MAP[hash_part] = path
+    url = f"{URL}/{hash_part}"
+    _FILE_URL_MAP[path] = url
+    return url
+
+
+def generate_static_url(file_path: Path):
+    return urllib_quote(f"{URL}/{_generate_hash_part(file_path)}")
+
+
+def _generate_hash_part(file_path: Path):
+    file_path = Path(file_path).resolve()
+    hash_name = file_system.generate_hash_name_from_path(file_path)
+    return f"{hash_name}/{file_path.name}"

instaui/fastapi_server/server.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from contextlib import contextmanager
 import inspect
 import os
 import multiprocessing
@@ -8,29 +9,36 @@ import __main__
 
 from fastapi import FastAPI
 from fastapi import Request
-from fastapi.responses import FileResponse, HTMLResponse
-from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
 import uvicorn
 from uvicorn.supervisors import ChangeReload
+import itertools
 
-from instaui.html_tools import to_json
+from instaui.html_tools import to_config_data
 from instaui.launch_collector import get_launch_collector
 from instaui.page_info import PageInfo
-from instaui.handlers import config_handler
-from instaui.systems import file_system
+
 from instaui import consts
-from instaui.runtime._app import get_app_slot
+from instaui.runtime._app import get_app_slot, get_default_app_slot
+from instaui.runtime.dataclass import JsLink, VueAppComponent
 from instaui.template import web_template
-from . import config_router
+
+
+from . import dependency_router
 from . import event_router
 from . import watch_router
 from . import debug_mode_router
 from .middlewares import RequestContextMiddleware
 from ._uvicorn import UvicornServer
-
+from . import resource
 
 APP_IMPORT_STRING = "instaui.fastapi_server.server:Server._instance.app"
 
+VUE_JS_HASH_LINK = resource.record_resource(consts.VUE_ES_JS_PATH)
+INSTAUI_JS_HASH_LINK = resource.record_resource(consts.APP_ES_JS_PATH)
+APP_CSS_LINK = resource.record_resource(consts.APP_CSS_PATH)
+TAILWIND_JS_HASH_LINK = resource.record_resource(consts.TAILWIND_JS_PATH)
+
 
 class Server:
     _instance: Optional[Server] = None
@@ -44,13 +52,11 @@ class Server:
     def __init__(self):
         self.app = FastAPI()
         self.app.add_middleware(RequestContextMiddleware)
-        config_router.create_router(self.app)
+        dependency_router.create_router(self.app)
         event_router.create_router(self.app)
         watch_router.create_router(self.app)
         debug_mode_router.create_router(self.app)
 
-        self._static_dir_url = _add_static_dir(self.app)
-
         for page_info in get_launch_collector()._page_router.values():
             self.register_page(page_info)
 
@@ -61,125 +67,134 @@ class Server:
 
         self._remove_route(info.path)
 
-        key = info.create_key()
-        config_handler.register_handler(key, info.func)
-        config_fetch_url = (
-            config_handler.ASYNC_URL if is_async else config_handler.SYNC_URL
-        )
+        if is_async:
 
-        @self.app.get(info.path)
-        def wrapper(request: Request):
-            page_loadding_json = None
-            if info.page_loading:
-                loadding_result = info.page_loading()
-                if loadding_result:
-                    return loadding_result
-                page_loadding_json = to_json()
-
-            html = self._to_web_html(
-                page_info=info,
-                config_fetch_url=config_fetch_url,
-                config_fetch_key=key,
-                query_path=info.path,
-                request=request,
-                page_loadding_json=page_loadding_json,
-            )
-            response = HTMLResponse(html)
-            return response
+            @self.app.get(info.path)
+            async def _(request: Request):
+                self._update_page_info(request, info)
+                with _execute_request_lifespans():
+                    await info.func()
+                html = self._to_web_html(
+                    page_info=info,
+                    request=request,
+                )
+
+                return HTMLResponse(html)
 
-        return wrapper
+        else:
+
+            @self.app.get(info.path)
+            def _(request: Request):
+                self._update_page_info(request, info)
+                with _execute_request_lifespans():
+                    info.func()
+                html = self._to_web_html(
+                    page_info=info,
+                    request=request,
+                )
+
+                return HTMLResponse(html)
 
     def _to_web_html(
         self,
         *,
         page_info: PageInfo,
-        query_path: str,
-        config_json: Optional[str] = None,
-        config_fetch_url: Optional[str] = None,
-        config_fetch_key: Optional[str] = None,
-        page_loadding_json: Optional[str] = None,
         request: Request,
     ):
-        system_slot = get_app_slot()
-        html_resource = system_slot._html_resource
-        page_info.apply_settings(html_resource)
-
-        html_resource.add_import_map(
-            "vue", self._static_dir_url + f"/{consts.VUE_ES_JS_PATH.name}"
+        config_data = to_config_data()
+
+        model = web_template.WebTemplateModel(
+            vue_js_link=VUE_JS_HASH_LINK,
+            instaui_js_link=INSTAUI_JS_HASH_LINK,
+            css_links=[
+                APP_CSS_LINK,
+            ],
+            config_dict=config_data,
         )
 
-        html_resource.add_import_map(
-            "instaui", self._static_dir_url + f"/{consts.APP_ES_JS_PATH.name}"
-        )
-        html_resource.add_css_link(consts.APP_CSS_PATH)
+        system_slot = get_app_slot()
+        default_app_slot = get_default_app_slot()
+        html_resource = system_slot._html_resource
+        default_html_resource = default_app_slot._html_resource
 
-        if html_resource.use_tailwind:
-            tailwind_url = self._static_dir_url + f"/{consts.TAILWIND_JS_PATH.name}"
-            html_resource.add_js_link(tailwind_url)
+        if html_resource.use_tailwind is None:
+            if default_html_resource.use_tailwind:
+                model.js_links.append(JsLink(TAILWIND_JS_HASH_LINK))
+        else:
+            if html_resource.use_tailwind:
+                model.js_links.append(JsLink(TAILWIND_JS_HASH_LINK))
 
         # register custom components
-        # TODO: use one get api to get all components
-        for component in system_slot._js_components:
+        for component in system_slot._component_dependencies:
             if not component.esm:
                 continue
-            url = self.add_static_file_route(component.esm)
-            html_resource.add_vue_app_component(name=component.name, url=url)
+
+            model.vue_app_component.append(
+                VueAppComponent(
+                    name=component.tag_name,
+                    url=resource.record_resource(component.esm),
+                )
+            )
 
             if component.css:
                 for css_link in component.css:
-                    html_resource.add_css_link(css_link)
+                    model.css_links.append(resource.record_resource(css_link))
 
         # register custom plugins
-        for plugin in system_slot._plugins:
+        for plugin in set(
+            itertools.chain(
+                system_slot._plugin_dependencies, default_app_slot._plugin_dependencies
+            )
+        ):
             if not plugin.esm:
                 continue
-            url = self.add_static_file_route(plugin.esm)
-            html_resource.add_vue_app_use(url)
+
+            model.vue_app_use.append(plugin.name)
+
+            model.add_extra_import_map(
+                plugin.name, resource.record_resource(plugin.esm)
+            )
 
             if plugin.css:
                 for css_link in plugin.css:
-                    html_resource.add_css_link(css_link)
+                    model.css_links.append(resource.record_resource(css_link))
 
         # css file link to web static link
-        html_resource._css_links = {
-            self.add_static_file_route(link) if isinstance(link, Path) else link: None
-            for link, attrs in html_resource._css_links.items()
-        }
+        for link, attrs in itertools.chain(
+            html_resource._css_links.items(), default_html_resource._css_links.items()
+        ):
+            if isinstance(link, Path):
+                model.css_links.append(resource.record_resource(link))
 
         # js file link to web static link
-        for info in html_resource._js_links:
+        for info in itertools.chain(
+            html_resource._js_links, default_html_resource._js_links
+        ):
             if isinstance(info.link, Path):
-                info.link = self.add_static_file_route(info.link)
+                model.js_links.append(JsLink((resource.record_resource(info.link))))
+
+        for js_code in itertools.chain(
+            html_resource._script_tags, default_html_resource._script_tags
+        ):
+            model.script_tags.append(js_code)
+
+        for sylte_code in itertools.chain(
+            html_resource._style_tags, default_html_resource._style_tags
+        ):
+            model.style_tags.append(sylte_code)
 
-        prefix = request.headers.get(
+        model.prefix = request.headers.get(
             "X-Forwarded-Prefix", request.scope.get("root_path", "")
         )
 
-        result = web_template.render_web_html(
-            config_json=config_json,
-            config_fetch_url=config_fetch_url,
-            config_fetch_key=config_fetch_key,
-            query_path_params=str(request.path_params),
-            query_params=dict(request.query_params),
-            query_path=query_path,
-            page_loadding_json=page_loadding_json,
-            prefix=prefix,
-        )
-        get_app_slot().reset_html_resource()
-        return result
-
-    def add_static_file_route(self, local_file: Path) -> str:
-        path = file_system.generate_static_url_from_file_path(local_file)
-        if path in self._registered_static_routes:
-            return path
-
-        @self.app.get(path)
-        def _() -> FileResponse:
-            return FileResponse(
-                local_file, headers={"Cache-Control": "public, max-age=3600"}
-            )
+        return web_template.render_web_html(model)
+
+    def _update_page_info(self, request: Request, page_info: PageInfo):
+        app = get_app_slot()
 
-        return path
+        app._page_path = page_info.path
+        app._page_params = request.path_params
+        app._query_params = dict(request.query_params)
 
     def _remove_route(self, path: str) -> None:
         self.app.routes[:] = [
@@ -236,11 +251,20 @@ class Server:
         assert isinstance(app, FastAPI), "app must be a FastAPI instance"
 
 
-def _add_static_dir(app: FastAPI):
-    url = file_system.generate_static_url_from_file_path(consts._STATIC_DIR)
-    app.mount(url, StaticFiles(directory=consts._STATIC_DIR))
-    return url
-
-
 def _split_args(args: str):
     return [a.strip() for a in args.split(",")]
+
+
+@contextmanager
+def _execute_request_lifespans():
+    events = [iter(event()) for event in get_launch_collector().page_request_lifespans]
+    for event in events:
+        next(event)
+
+    yield
+
+    for event in events:
+        try:
+            next(event)
+        except StopIteration:
+            pass