✨ feat!(ui): 重构图表组件架构，实现数据与样式分离 (#2035)

* ✨ feat!(ui): 重构图表组件架构，实现数据与样式分离

🏗️ **架构重构**
- 移除charts.py中所有硬编码样式参数(grid、tooltip、legend等)
- 将样式配置迁移至主题层style.json文件
- 统一图表模板消费样式文件的能力

📊 **图表组件优化**
- bar_chart: 移除grid和坐标轴show参数
- pie_chart: 移除tooltip、legend样式和series视觉参数
- line_chart: 移除tooltip、grid和坐标轴配置
- radar_chart: 移除tooltip硬编码

🎨 **主题系统增强**
- 新增pie_chart、line_chart、radar_chart的style.json配置
- 更新bar_chart/style.json，添加grid、xAxis、yAxis样式
- 所有图表模板支持deepMerge样式合并逻辑

🔧 **Breaking Changes**
- 图表工厂函数不再接受样式参数
- 主题开发者现可通过style.json完全定制图表外观
- 提升组件可维护性和主题灵活性

* 📦️ build(pyinstaller): 引入 resources.spec 并更新 .gitignore 规则

* 🚨 auto fix by pre-commit hooks

---------

Co-authored-by: webjoin111 <455457521@qq.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

zhenxun/services/renderer/service.py

@@ -1,13 +1,18 @@
 import asyncio
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
 import hashlib
+import inspect
 from pathlib import Path
-from typing import ClassVar, Literal
+from typing import Any, ClassVar
 
 import aiofiles
 from jinja2 import (
+    ChoiceLoader,
     Environment,
     FileSystemLoader,
+    PrefixLoader,
+    TemplateNotFound,
     select_autoescape,
 )
 from nonebot.utils import is_coroutine_callable
@@ -17,33 +22,101 @@ from zhenxun.configs.config import Config
 from zhenxun.configs.path_config import THEMES_PATH, UI_CACHE_PATH
 from zhenxun.services.log import logger
 from zhenxun.utils.exception import RenderingError
+from zhenxun.utils.pydantic_compat import _dump_pydantic_obj
 
+from .config import RESERVED_TEMPLATE_KEYS
 from .engine import get_screenshot_engine
 from .protocols import Renderable, RenderResult, ScreenshotEngine
-from .theme import ThemeManager
+from .registry import asset_registry
+from .theme import RelativePathEnvironment, ThemeManager
+
+
+@dataclass
+class RenderContext:
+    """单次渲染任务的上下文对象，用于状态传递和缓存。"""
+
+    renderer: "RendererService"
+    theme_manager: ThemeManager
+    screenshot_engine: ScreenshotEngine
+    component: Renderable
+    use_cache: bool
+    render_options: dict[str, Any]
+    resolved_template_paths: dict[str, str] = field(default_factory=dict)
+    resolved_style_paths: dict[str, Path | None] = field(default_factory=dict)
+    collected_asset_styles: set[str] = field(default_factory=set)
+    collected_scripts: set[str] = field(default_factory=set)
+    collected_inline_css: list[str] = field(default_factory=list)
+    processed_components: set[int] = field(default_factory=set)
 
 
 class RendererService:
     """
     图片渲染服务的统一门面。
 
-    负责编排和调用底层渲染服务，提供统一的渲染接口。
-    支持多种渲染方式：组件渲染、模板渲染等。
+    作为UI渲染的中心枢纽，负责编排和调用底层服务，提供统一的渲染接口。
+    主要职责包括：
+    - 管理和加载UI主题 (通过 ThemeManager)。
+    - 使用Jinja2引擎将组件数据模型 (`Renderable`) 渲染为HTML。
+    - 调用截图引擎 (ScreenshotEngine) 将HTML转换为图片。
+    - 处理插件注册的模板、过滤器和全局函数。
+    - (可选) 管理渲染结果的缓存。
     """
 
     _plugin_template_paths: ClassVar[dict[str, Path]] = {}
 
     def __init__(self):
+        self._jinja_env: Environment | None = None
         self._theme_manager: ThemeManager | None = None
         self._screenshot_engine: ScreenshotEngine | None = None
         self._initialized = False
         self._init_lock = asyncio.Lock()
         self._custom_filters: dict[str, Callable] = {}
         self._custom_globals: dict[str, Callable] = {}
-        self._markdown_styles: dict[str, Path] = {}
+
+        self.filter("dump_json")(self._pydantic_tojson_filter)
+
+    def _create_jinja_env(self) -> Environment:
+        """
+        创建并配置 Jinja2 渲染环境。
+
+        构建一个完整的 Jinja2 环境，包含：
+        - PrefixLoader：用于插件模板的命名空间加载
+        - FileSystemLoader：用于主题模板的文件系统加载
+        - RelativePathEnvironment：支持模板间相对路径引用的自定义环境
+
+        返回:
+            Environment: 完全配置好的 Jinja2 环境实例，准备接收自定义过滤器和全局函数。
+        """
+        prefix_loader = PrefixLoader(
+            {
+                namespace: FileSystemLoader(str(path.absolute()))
+                for namespace, path in self._plugin_template_paths.items()
+            }
+        )
+        theme_loader = FileSystemLoader(str(THEMES_PATH / "default"))
+        final_loader = ChoiceLoader([prefix_loader, theme_loader])
+
+        env = RelativePathEnvironment(
+            loader=final_loader,
+            enable_async=True,
+            autoescape=select_autoescape(["html", "xml"]),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+        return env
 
     def register_template_namespace(self, namespace: str, path: Path):
-        """[新增] 插件注册模板路径的入口点"""
+        """
+        为插件注册一个Jinja2模板命名空间。
+
+        这允许插件在自己的目录中维护模板，并通过
+        `{% include '@namespace/template.html' %}` 的方式引用它们，
+        避免了与核心或其他插件的模板命名冲突。
+
+        参数:
+            namespace: 插件的唯一命名空间，例如插件名。
+            path: 包含该插件模板的目录路径。
+        """
         if namespace in self._plugin_template_paths:
             logger.warning(f"模板命名空间 '{namespace}' 已被注册，将被覆盖。")
         if not path.is_dir():
@@ -52,18 +125,25 @@ class RendererService:
 
     def register_markdown_style(self, name: str, path: Path):
         """
-        为 Markdown 渲染器注册一个具名样式。
+        为 Markdown 渲染器注册一个具名样式 (委托给 AssetRegistry)。
+
+        参数:
+            name (str): 样式的唯一名称，例如 'cyberpunk'。
+            path (Path): 指向该样式的CSS文件路径。
         """
-        if name in self._markdown_styles:
-            logger.warning(f"Markdown 样式 '{name}' 已被注册，将被覆盖。")
         if not path.is_file():
             raise ValueError(f"提供的路径 '{path}' 不是一个有效的 CSS 文件。")
-        self._markdown_styles[name] = path
-        logger.debug(f"已注册 Markdown 样式 '{name}' -> '{path}'")
+        asset_registry.register_markdown_style(name, path)
 
     def filter(self, name: str) -> Callable:
         """
         装饰器：注册一个自定义 Jinja2 过滤器。
+
+        参数:
+            name: 过滤器在模板中的调用名称。
+
+        返回:
+            Callable: 用于装饰过滤器函数的装饰器。
         """
 
         def decorator(func: Callable) -> Callable:
@@ -78,6 +158,12 @@ class RendererService:
     def global_function(self, name: str) -> Callable:
         """
         装饰器：注册一个自定义 Jinja2 全局函数。
+
+        参数:
+            name: 函数在模板中的调用名称。
+
+        返回:
+            Callable: 用于装饰全局函数的装饰器。
         """
 
         def decorator(func: Callable) -> Callable:
@@ -90,46 +176,143 @@ class RendererService:
         return decorator
 
     async def initialize(self):
-        """[新增] 延迟初始化方法，在 on_startup 钩子中调用"""
+        """
+        [新增] 延迟初始化方法，在 on_startup 钩子中调用。
+
+        负责初始化截图引擎和主题管理器，确保在首次渲染前所有依赖都已准备就绪。
+        使用锁来防止并发初始化。
+        """
         if self._initialized:
             return
         async with self._init_lock:
             if self._initialized:
                 return
 
+            self._jinja_env = self._create_jinja_env()
+
+            self._jinja_env.filters.update(self._custom_filters)
+            self._jinja_env.globals.update(self._custom_globals)
+
             self._screenshot_engine = get_screenshot_engine()
-            self._theme_manager = ThemeManager(
-                self._plugin_template_paths,
-                self._custom_filters,
-                self._custom_globals,
-                self._markdown_styles,
-            )
+
+            self._theme_manager = ThemeManager(self._jinja_env)
 
             current_theme_name = Config.get_config("UI", "THEME", "default")
             await self._theme_manager.load_theme(current_theme_name)
             self._initialized = True
 
+    async def _collect_dependencies_recursive(
+        self, component: Renderable, context: "RenderContext"
+    ):
+        """
+        递归遍历组件树，收集所有依赖项（CSS, JS, 额外CSS）并存入上下文。
+
+        这是实现组件化样式和脚本管理的基础，确保即使是深层嵌套的组件
+        所需的资源也能被正确加载到最终的HTML页面中。
+        """
+        component_id = id(component)
+        if component_id in context.processed_components:
+            return
+        context.processed_components.add(component_id)
+
+        component_path_base = str(component.template_name)
+        manifest = await context.theme_manager.get_template_manifest(
+            component_path_base
+        )
+
+        style_paths_to_load = []
+        if manifest and manifest.styles:
+            styles = (
+                [manifest.styles]
+                if isinstance(manifest.styles, str)
+                else manifest.styles
+            )
+            for style_path in styles:
+                full_style_path = str(Path(component_path_base) / style_path).replace(
+                    "\\", "/"
+                )
+                style_paths_to_load.append(full_style_path)
+        else:
+            resolved_template_name = (
+                await context.theme_manager._resolve_component_template(
+                    component, context
+                )
+            )
+            conventional_style_path = str(
+                Path(resolved_template_name).with_name("style.css")
+            ).replace("\\", "/")
+            style_paths_to_load.append(conventional_style_path)
+
+        for css_template_path in style_paths_to_load:
+            try:
+                css_template = context.theme_manager.jinja_env.get_template(
+                    css_template_path
+                )
+                theme_context = {
+                    "theme": context.theme_manager.jinja_env.globals.get("theme", {})
+                }
+                css_content = await css_template.render_async(**theme_context)
+                context.collected_inline_css.append(css_content)
+            except TemplateNotFound:
+                pass
+
+        context.collected_scripts.update(component.get_required_scripts())
+        context.collected_asset_styles.update(component.get_required_styles())
+
+        if hasattr(component, "get_extra_css"):
+            res = component.get_extra_css(context)
+            css_str = await res if inspect.isawaitable(res) else str(res)
+            if css_str:
+                context.collected_inline_css.append(css_str)
+
+        for child in component.get_children():
+            if child:
+                await self._collect_dependencies_recursive(child, context)
+
     async def _render_component(
-        self, component: Renderable, use_cache: bool = False, **render_options
+        self,
+        context: "RenderContext",
     ) -> RenderResult:
         """
         核心的私有渲染方法，执行完整的渲染流程。
+
+        执行步骤:
+        1.  **缓存检查**: 如果启用缓存，则根据组件模板名和渲染数据生成缓存键，
+            并尝试从文件系统中读取缓存图片。
+        2.  **组件准备**: 调用 `component.prepare()` 生命周期钩子，允许组件执行
+            异步数据加载。
+        3.  **依赖收集**: 调用 `_collect_dependencies_recursive` 遍历组件树，
+            收集所有需要的CSS文件、JS文件和内联CSS。
+        4.  **HTML渲染**: 调用 `ThemeManager` 将组件数据模型渲染为HTML字符串。
+            此步骤会处理独立模板和主题内模板两种情况。
+        5.  **截图**: 调用 `ScreenshotEngine` 将生成的HTML转换为图片字节。
+        6.  **缓存写入**: 如果缓存未命中且启用了缓存，将生成的图片写入文件系统。
+        """
+        return await self._apply_caching_layer(self._render_component_core, context)
+
+    async def _apply_caching_layer(
+        self,
+        core_render_func: Callable[..., Awaitable[RenderResult]],
+        context: "RenderContext",
+    ) -> RenderResult:
+        """
+        一个高阶函数，为核心渲染逻辑提供缓存层。
+        它负责处理缓存的读取和写入，而将实际的渲染工作委托给传入的函数。
         """
         cache_path = None
-        if Config.get_config("UI", "CACHE") and use_cache:
+        component = context.component
+
+        if Config.get_config("UI", "CACHE") and context.use_cache:
             try:
                 template_name = component.template_name
                 data_dict = component.get_render_data()
-
                 resolved_data_dict = {}
                 for key, value in data_dict.items():
                     if is_coroutine_callable(value):  # type: ignore
                         resolved_data_dict[key] = await value
                     else:
                         resolved_data_dict[key] = value
-
                 data_str = json.dumps(resolved_data_dict, sort_keys=True)
-
                 cache_key_str = f"{template_name}:{data_str}"
                 cache_filename = (
                     f"{hashlib.sha256(cache_key_str.encode()).hexdigest()}.png"
@@ -148,43 +331,46 @@ class RendererService:
                 logger.warning(f"UI缓存读取失败: {e}", e=e)
                 cache_path = None
 
+        result = await core_render_func(context)
+
+        if (
+            Config.get_config("UI", "CACHE")
+            and context.use_cache
+            and cache_path
+            and result.image_bytes
+        ):
+            try:
+                async with aiofiles.open(cache_path, "wb") as f:
+                    await f.write(result.image_bytes)
+                logger.debug(f"UI缓存写入成功: {cache_path}")
+            except Exception as e:
+                logger.warning(f"UI缓存写入失败: {e}", e=e)
+
+        return result
+
+    async def _render_component_core(self, context: "RenderContext") -> RenderResult:
+        """
+        纯粹的核心渲染逻辑，不包含任何缓存处理。
+        此方法负责从组件数据模型生成最终的图片字节和HTML。
+        """
+        component = context.component
+
         try:
             if not self._initialized:
                 await self.initialize()
-            assert self._theme_manager is not None, "ThemeManager 未初始化"
-            assert self._screenshot_engine is not None, "ScreenshotEngine 未初始化"
-
-            if hasattr(component, "prepare"):
-                await component.prepare()
-
-            required_scripts = set(component.get_required_scripts())
-            required_styles = set(component.get_required_styles())
-
-            if hasattr(component, "required_scripts"):
-                required_scripts.update(getattr(component, "required_scripts"))
-            if hasattr(component, "required_styles"):
-                required_styles.update(getattr(component, "required_styles"))
-
-            data_dict = component.get_render_data()
-
-            component_render_options = data_dict.get("render_options", {})
-            if not isinstance(component_render_options, dict):
-                component_render_options = {}
-
-            manifest_options = {}
-            if manifest := await self._theme_manager.get_template_manifest(
-                component.template_name
-            ):
-                manifest_options = manifest.render_options or {}
+            assert context.theme_manager is not None, "ThemeManager 未初始化"
+            assert context.screenshot_engine is not None, "ScreenshotEngine 未初始化"
 
             if (
-                getattr(component, "_is_standalone_template", False)
-                and hasattr(component, "template_path")
+                hasattr(component, "template_path")
                 and isinstance(
-                    template_path := getattr(component, "template_path"), Path
+                    template_path := getattr(component, "template_path"),
+                    Path,
                 )
                 and template_path.is_absolute()
             ):
+                await component.prepare()
+
                 logger.debug(f"正在渲染独立模板: '{template_path}'", "RendererService")
 
                 template_dir = template_path.parent
@@ -195,45 +381,69 @@ class RendererService:
                     autoescape=select_autoescape(["html", "xml"]),
                 )
 
-                temp_env.globals["theme"] = self._theme_manager.jinja_env.globals.get(
-                    "theme", {}
+                temp_env.globals.update(context.theme_manager.jinja_env.globals)
+                temp_env.globals["asset"] = (
+                    context.theme_manager._create_standalone_asset_loader(template_dir)
                 )
-                temp_env.filters["md"] = self._theme_manager._markdown_filter
+                temp_env.filters["md"] = context.theme_manager._markdown_filter
 
+                data_dict = component.get_render_data()
                 template = temp_env.get_template(template_path.name)
-                html_content = await template.render_async(data=data_dict)
+
+                template_context = {
+                    "theme": context.theme_manager.jinja_env.globals.get("theme", {}),
+                    "data": data_dict,
+                }
+                for key, value in data_dict.items():
+                    if key in RESERVED_TEMPLATE_KEYS:
+                        logger.warning(
+                            f"模板数据键 '{key}' 与渲染器保留关键字冲突，"
+                            f"在模板 '{component.template_name}' 中请使用 "
+                            f"'data.{key}' 访问。"
+                        )
+                    else:
+                        template_context[key] = value
+                html_content = await template.render_async(**template_context)
+
+                component_render_options = data_dict.get("render_options", {})
+                if not isinstance(component_render_options, dict):
+                    component_render_options = {}
 
                 final_render_options = component_render_options.copy()
-                final_render_options.update(render_options)
+                final_render_options.update(context.render_options)
 
-                image_bytes = await self._screenshot_engine.render(
+                image_bytes = await context.screenshot_engine.render(
                     html=html_content,
                     base_url_path=template_dir,
                     **final_render_options,
                 )
 
-                if Config.get_config("UI", "CACHE") and use_cache and cache_path:
-                    try:
-                        async with aiofiles.open(cache_path, "wb") as f:
-                            await f.write(image_bytes)
-                        logger.debug(f"UI缓存写入成功: {cache_path}")
-                    except Exception as e:
-                        logger.warning(f"UI缓存写入失败: {e}", e=e)
-
                 return RenderResult(image_bytes=image_bytes, html_content=html_content)
 
             else:
+                await component.prepare()
+                await self._collect_dependencies_recursive(component, context)
+
+                data_dict = component.get_render_data()
+                component_render_options = data_dict.get("render_options", {})
+                if not isinstance(component_render_options, dict):
+                    component_render_options = {}
+
+                manifest_options = {}
+                if manifest := await context.theme_manager.get_template_manifest(
+                    component.template_name
+                ):
+                    manifest_options = manifest.render_options or {}
+
                 final_render_options = component_render_options.copy()
                 final_render_options.update(manifest_options)
-                final_render_options.update(render_options)
+                final_render_options.update(context.render_options)
 
-                if not self._theme_manager.current_theme:
+                if not context.theme_manager.current_theme:
                     raise RenderingError("渲染失败：主题未被正确加载。")
 
-                html_content = await self._theme_manager._render_component_to_html(
-                    component,
-                    required_scripts=list(required_scripts),
-                    required_styles=list(required_styles),
+                html_content = await context.theme_manager._render_component_to_html(
+                    context,
                     **final_render_options,
                 )
 
@@ -241,20 +451,12 @@ class RendererService:
                 screenshot_options.pop("extra_css", None)
                 screenshot_options.pop("frameless", None)
 
-                image_bytes = await self._screenshot_engine.render(
+                image_bytes = await context.screenshot_engine.render(
                     html=html_content,
                     base_url_path=THEMES_PATH.parent,
                     **screenshot_options,
                 )
 
-                if Config.get_config("UI", "CACHE") and use_cache and cache_path:
-                    try:
-                        async with aiofiles.open(cache_path, "wb") as f:
-                            await f.write(image_bytes)
-                        logger.debug(f"UI缓存写入成功: {cache_path}")
-                    except Exception as e:
-                        logger.warning(f"UI缓存写入失败: {e}", e=e)
-
                 return RenderResult(image_bytes=image_bytes, html_content=html_content)
 
         except Exception as e:
@@ -271,27 +473,37 @@ class RendererService:
         self,
         component: Renderable,
         use_cache: bool = False,
-        debug_mode: Literal["none", "log"] = "none",
         **render_options,
     ) -> bytes:
         """
         统一的、多态的渲染入口，直接返回图片字节。
 
         参数:
-            component: 一个 Renderable 实例 (如 RenderableComponent) 或一个
-                      模板路径字符串。
+            component: 一个 `Renderable` 实例 (例如通过 `TableBuilder().build()` 创建)。
             use_cache: (可选) 是否启用渲染缓存，默认为 False。
-            **render_options: 传递给底层渲染引擎的额外参数。
+            **render_options: 传递给底层截图引擎的额外参数，例如 `viewport`。
 
         返回:
-            bytes: 渲染后的图片数据。
+            bytes: 渲染后的PNG图片字节数据。
+
+        异常:
+            RenderingError: 当渲染流程中任何步骤失败时抛出。
         """
-        result = await self._render_component(
-            component,
+        if not self._initialized:
+            await self.initialize()
+        assert self._theme_manager is not None, "ThemeManager 未初始化"
+        assert self._screenshot_engine is not None, "ScreenshotEngine 未初始化"
+
+        context = RenderContext(
+            renderer=self,
+            theme_manager=self._theme_manager,
+            screenshot_engine=self._screenshot_engine,
+            component=component,
             use_cache=use_cache,
-            **render_options,
+            render_options=render_options,
         )
-        if debug_mode == "log" and result.html_content:
+        result = await self._render_component(context)
+        if Config.get_config("UI", "DEBUG_MODE") and result.html_content:
             logger.info(
                 f"--- [UI DEBUG] HTML for {component.__class__.__name__} ---\n"
                 f"{result.html_content}\n"
@@ -301,17 +513,44 @@ class RendererService:
             raise RenderingError("渲染成功但未能生成图片字节数据。")
         return result.image_bytes
 
-    async def render_to_html(self, component: Renderable) -> str:
-        """调试方法：只执行到HTML生成步骤。"""
+    async def render_to_html(
+        self, component: Renderable, frameless: bool = False
+    ) -> str:
+        """
+        调试方法：只执行到HTML生成步骤，不进行截图。
+
+        参数:
+            component: 一个 `Renderable` 实例。
+            frameless: 是否以无边框模式渲染（只渲染HTML片段）。
+
+        返回:
+            str: 最终渲染出的完整HTML字符串。
+        """
         if not self._initialized:
             await self.initialize()
         assert self._theme_manager is not None, "ThemeManager 未初始化"
+        assert self._screenshot_engine is not None, "ScreenshotEngine 未初始化"
 
-        return await self._theme_manager._render_component_to_html(component)
+        context = RenderContext(
+            renderer=self,
+            theme_manager=self._theme_manager,
+            screenshot_engine=self._screenshot_engine,
+            component=component,
+            use_cache=False,
+            render_options={"frameless": frameless},
+        )
+        await self._collect_dependencies_recursive(component, context)
+        return await self._theme_manager._render_component_to_html(
+            context, frameless=frameless
+        )
 
     async def reload_theme(self) -> str:
         """
         重新加载当前主题的配置和样式，并清除缓存的Jinja环境。
+        这在开发主题时非常有用，可以热重载主题更改。
+
+        返回:
+            str: 已成功加载的主题名称。
         """
         if not self._initialized:
             await self.initialize()
@@ -321,3 +560,37 @@ class RendererService:
         await self._theme_manager.load_theme(current_theme_name)
         logger.info(f"主题 '{current_theme_name}' 已成功重载。")
         return current_theme_name
+
+    def list_available_themes(self) -> list[str]:
+        """获取所有可用主题的列表。"""
+        if not self._initialized or not self._theme_manager:
+            raise RuntimeError("ThemeManager尚未初始化。")
+        return self._theme_manager.list_available_themes()
+
+    async def switch_theme(self, theme_name: str) -> str:
+        """
+        切换UI主题，加载新主题并持久化配置。
+
+        返回:
+            str: 已成功切换到的主题名称。
+        """
+        if not self._initialized or not self._theme_manager:
+            await self.initialize()
+        assert self._theme_manager is not None
+
+        available_themes = self._theme_manager.list_available_themes()
+        if theme_name not in available_themes:
+            raise FileNotFoundError(
+                f"主题 '{theme_name}' 不存在。可用主题: {', '.join(available_themes)}"
+            )
+
+        await self._theme_manager.load_theme(theme_name)
+        Config.set_config("UI", "THEME", theme_name, auto_save=True)
+        logger.info(f"UI主题已切换为: {theme_name}")
+        return theme_name
+
+    @staticmethod
+    def _pydantic_tojson_filter(obj: Any) -> str:
+        """一个能够递归处理Pydantic模型及其集合的 tojson 过滤器"""
+        dumped_obj = _dump_pydantic_obj(obj)
+        return json.dumps(dumped_obj, ensure_ascii=False)