feat(layout): inject ThemeManager by default; add global page stores and callbacks

fix(markdown_report): remove header store to avoid duplicate IDs

chore: bump version to 1.2.5

Author: iamgp

README.md

@@ -191,30 +191,35 @@ uv pip install -e .
 Releases are driven by tags. Publishing runs in CI and a smoke test validates PyPI install.
 
 Prerequisites:
+
 - GitHub Actions secret: `PYPI_API_TOKEN` (PyPI API token with upload permission)
 
 Subpackages
+
 - dashkit_table
-  1) Bump version in `src/dashkit_table/pyproject.toml`
-  2) Commit and push (if ignored, force add): `git add -f src/dashkit_table/pyproject.toml && git commit -m "release(table): X.Y.Z" && git push`
-  3) Tag and push: `git tag dashkit_table-vX.Y.Z && git push origin dashkit_table-vX.Y.Z`
+  1. Bump version in `src/dashkit_table/pyproject.toml`
+  2. Commit and push (if ignored, force add): `git add -f src/dashkit_table/pyproject.toml && git commit -m "release(table): X.Y.Z" && git push`
+  3. Tag and push: `git tag dashkit_table-vX.Y.Z && git push origin dashkit_table-vX.Y.Z`
 - dashkit_kiboui
-  1) Bump version in `src/dashkit_kiboui/pyproject.toml`
-  2) Commit and push
-  3) Tag and push: `git tag dashkit_kiboui-vX.Y.Z && git push origin dashkit_kiboui-vX.Y.Z`
+  1. Bump version in `src/dashkit_kiboui/pyproject.toml`
+  2. Commit and push
+  3. Tag and push: `git tag dashkit_kiboui-vX.Y.Z && git push origin dashkit_kiboui-vX.Y.Z`
 
 Main package (dash-dashkit)
+
 - Bump version in `pyproject.toml` (update subpackage minimums as needed)
 - Commit and push
-- Tag and push: `git tag dash-dashkit-vX.Y.Z && git push origin dash-dashkit-vX.Y.Z`
+- Tag and push: `git tag dash-dashkit-vX.Y.Z && git push origin dashkit-vX.Y.Z`
   - Legacy form `vX.Y.Z` is also supported
 
 CI workflows
+
 - Publish: builds the package for the matching tag and uploads to PyPI
 - Smoke: installs the just-published version in a clean venv and imports/instantiates components
 - Manual fallback: both workflows support `workflow_dispatch` with `tag_name` if you need to re-run
 
 Notes
+
 - If `src/dashkit_table` is ignored in `.gitignore`, use `git add -f` or remove the ignore entry
 - Tag patterns must match exactly as above (component-vX.Y.Z)
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dash-dashkit"
-version = "1.2.4"
+version = "1.2.5"
 description = "Modern dashboard components for Dash applications"
 readme = "README.md"
 requires-python = ">=3.10"

scripts/bump_version.py

@@ -14,7 +14,9 @@
     "shadcn": ROOT / "src" / "dashkit_shadcn" / "pyproject.toml",
 }
 
-VERSION_RE = re.compile(r'^(\s*version\s*=\s*")(?P<ver>\d+\.\d+\.\d+)("\s*)$', re.MULTILINE)
+VERSION_RE = re.compile(
+    r'^(\s*version\s*=\s*")(?P<ver>\d+\.\d+\.\d+)("\s*)$', re.MULTILINE
+)
 PKG_CONSTRAINTS = {
     "table": "dashkit_table",
     "kiboui": "dashkit_kiboui",
@@ -41,12 +43,24 @@ def parse_args():
         help="Prompt to select repos and bump type (default when no args)",
     )
     # Release/VC options
-    p.add_argument("--commit", action="store_true", help="Create a Git commit with the changes")
+    p.add_argument(
+        "--commit", action="store_true", help="Create a Git commit with the changes"
+    )
     p.add_argument("--tag", action="store_true", help="Create a Git tag after commit")
-    p.add_argument("--tag-name", default=None, help="Explicit tag name to create (overrides prefix+version)")
-    p.add_argument("--tag-prefix", default="v", help="Prefix for tag when --tag-name not provided (default: v)")
+    p.add_argument(
+        "--tag-name",
+        default=None,
+        help="Explicit tag name to create (overrides prefix+version)",
+    )
+    p.add_argument(
+        "--tag-prefix",
+        default="v",
+        help="Prefix for tag when --tag-name not provided (default: v)",
+    )
     p.add_argument("--push", action="store_true", help="Push commit and tag to remote")
-    p.add_argument("--remote", default="origin", help="Remote name for push (default: origin)")
+    p.add_argument(
+        "--remote", default="origin", help="Remote name for push (default: origin)"
+    )
     return p.parse_args()
 
 
@@ -100,7 +114,7 @@ def update_root_constraints(root_path: Path, new_versions: dict[str, str]) -> bo
         pattern = re.compile(rf'("{re.escape(pkg)}>=)(\d+\.\d+\.\d+)(")')
 
         def repl(mm: re.Match) -> str:
-            return f"{mm.group(1)}{new_ver}{mm.group(3)}"
+            return f"{mm.group(1)}{new_ver}{mm.group(3)}"  # noqa: B023
 
         new_content, n = pattern.subn(repl, content)
         if n:
@@ -113,8 +127,14 @@ def repl(mm: re.Match) -> str:
 
 # ---------------- Git helpers -----------------
 
+
 def _run_git(*args: str) -> subprocess.CompletedProcess:
-    return subprocess.run(["git", *args], cwd=str(ROOT), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    return subprocess.run(
+        ["git", *args],
+        cwd=str(ROOT),
+        capture_output=True,
+        text=True,
+    )
 
 
 def _ensure_git_repo() -> bool:
@@ -145,9 +165,12 @@ def _git_push(remote: str, push_tags: bool) -> None:
 
 # ---------------- Interactive helpers -----------------
 
+
 def _prompt_select_repos() -> list[str]:
     keys = list(REPOS.keys())
-    print("Select repos to bump (comma-separated numbers or names; 'all' for all; blank to cancel):")
+    print(
+        "Select repos to bump (comma-separated numbers or names; 'all' for all; blank to cancel):"
+    )
     for i, k in enumerate(keys, 1):
         print(f"  {i}) {k}")
     sel = input("> ").strip()
@@ -175,7 +198,14 @@ def _prompt_select_repos() -> list[str]:
 def _prompt_bump_type() -> str:
     print("Select bump type [1] patch  [2] minor  [3] major (default: 1):")
     sel = input("> ").strip()
-    mapping = {"1": "patch", "2": "minor", "3": "major", "patch": "patch", "minor": "minor", "major": "major"}
+    mapping = {
+        "1": "patch",
+        "2": "minor",
+        "3": "major",
+        "patch": "patch",
+        "minor": "minor",
+        "major": "major",
+    }
     if not sel:
         return "patch"
     kind = mapping.get(sel.lower())
@@ -232,7 +262,9 @@ def main():
         bump_type = args.type
         unknown = [r for r in targets if r not in REPOS]
         if unknown:
-            raise SystemExit(f"Unknown repos: {', '.join(unknown)}. Valid: {', '.join(REPOS)}")
+            raise SystemExit(
+                f"Unknown repos: {', '.join(unknown)}. Valid: {', '.join(REPOS)}"
+            )
 
     bumped: dict[str, str] = {}
     changed_paths: list[Path] = []
@@ -257,7 +289,9 @@ def main():
     # Optionally commit, tag, and push
     if commit_flag or tag_flag or push_flag:
         if not _ensure_git_repo():
-            raise SystemExit("Not a Git repo (or Git not available); cannot commit/tag/push.")
+            raise SystemExit(
+                "Not a Git repo (or Git not available); cannot commit/tag/push."
+            )
         if changed_paths:
             _git_add(changed_paths)
         commit_msg_parts = [f"{name} {ver}" for name, ver in bumped.items()]
@@ -279,13 +313,15 @@ def main():
             tags_to_create: list[tuple[str, str]] = []  # (tag_name, message)
             if tag_name and len(bumped) == 1:
                 # Single repo: respect explicit tag name
-                only_repo = next(iter(bumped.keys()))
+                next(iter(bumped.keys()))
                 tn = tag_name
                 msg = f"Release {tn} ({'; '.join(commit_msg_parts)})"
                 tags_to_create.append((tn, msg))
             else:
                 if tag_name and len(bumped) > 1:
-                    print("Note: --tag-name ignored when tagging multiple repos; using per-repo conventions.")
+                    print(
+                        "Note: --tag-name ignored when tagging multiple repos; using per-repo conventions."
+                    )
                 for repo_key, ver in bumped.items():
                     prefix = TAG_PREFIXES.get(repo_key, tag_prefix)
                     tn = f"{prefix}{ver}"

src/dashkit/__init__.py

@@ -6,6 +6,7 @@
 """
 
 from pathlib import Path
+
 from flask import send_from_directory
 
 from .buttons import PrimaryButton, SecondaryButton
@@ -45,9 +46,11 @@ def setup_app(app, assets_folder=None, include_dashkit_css: bool = True):
     if include_dashkit_css and pkg_assets.exists():
         route_attr = "_dashkit_assets_route_registered"
         if not getattr(app.server, route_attr, False):
+
             @app.server.route("/dashkit-assets/<path:filename>")
             def _dashkit_assets(filename: str):  # type: ignore
                 return send_from_directory(str(pkg_assets), filename)
+
             setattr(app.server, route_attr, True)
 
     app.index_string = """
@@ -81,12 +84,18 @@ def _dashkit_assets(filename: str):  # type: ignore
         </footer>
     </body>
 </html>
-""".replace("{dashkit_css}", "<link href=\"/dashkit-assets/style.css\" rel=\"stylesheet\">" if include_dashkit_css and pkg_assets.exists() else "")
+""".replace(
+        "{dashkit_css}",
+        '<link href="/dashkit-assets/style.css" rel="stylesheet">'
+        if include_dashkit_css and pkg_assets.exists()
+        else "",
+    )
 
 
 # Resolve version dynamically from installed package metadata
 try:
-    from importlib.metadata import PackageNotFoundError, version as _pkg_version
+    from importlib.metadata import version as _pkg_version
+
     __version__ = _pkg_version("dash-dashkit")
 except Exception:
     __version__ = "0.0.0"

src/dashkit/charts.py

@@ -2,4 +2,4 @@
 from dashkit_shadcn import AreaChart, BarChart, ChartContainer  # noqa: F401
 
 # Re-export for convenience
-__all__ = ["AreaChart", "BarChart", "ChartContainer"]
+__all__ = ["AreaChart", "BarChart", "ChartContainer"]

src/dashkit/layout.py

@@ -1,17 +1,20 @@
 from typing import Any
 
+import dash
 import dash_mantine_components as dmc
-from dash import html
+from dash import Input, Output, callback, clientside_callback, dcc, html
 
 from .header import create_header
 from .sidebar import create_sidebar
+from .theme_manager import ThemeManager
 
 
 def create_layout(
     content: html.Div | None = None,
     sidebar_config: dict[str, Any] | None = None,
     header_config: dict[str, Any] | None = None,
     content_padding: str = "p-8",
+    include_theme_manager: bool = True,
 ) -> html.Div:
     """Create the main layout with configurable sidebar and header.
 
@@ -20,6 +23,7 @@ def create_layout(
         sidebar_config: Configuration for sidebar with brand name and initial
         header_config: Configuration for header with page_title, actions, etc.
         content_padding: CSS class for content padding (default: "p-8")
+        include_theme_manager: When True, injects ThemeManager (Location + theme stores/callbacks)
     """
     if content is None:
         content = html.Div(
@@ -53,6 +57,11 @@ def create_layout(
     return dmc.MantineProvider(
         html.Div(
             [
+                # Theme and location management
+                ThemeManager() if include_theme_manager else None,
+                # Global page stores for header + page config
+                dcc.Store(id="page_header_config", data={}),
+                dcc.Store(id="page_config", data={}),
                 # Sidebar
                 create_sidebar(
                     brand_name=sidebar_config["brand_name"],
@@ -93,3 +102,53 @@ def create_layout(
             className="flex h-screen bg-white dark:bg-dashkit-surface font-sans",
         )
     )
+
+
+# Register page state callbacks at import time so apps don't need to define them
+@callback(
+    [
+        Output("page_header_config", "data"),
+        Output("page_config", "data"),
+    ],
+    Input("url", "pathname", allow_optional=True),
+)
+def _update_page_config(pathname: str | None):
+    """Update header + page config stores from Dash page registry.
+
+    This runs whenever the URL changes. If `url` isn't present, it will be
+    skipped due to allow_optional.
+    """
+    header_config = {"title": "Dashboard", "icon": ""}
+    page_config = {"content_padding": "p-8"}
+
+    if pathname:
+        for page in dash.page_registry.values():
+            if page.get("path") == pathname:
+                header_config = {
+                    "title": page.get("title", ""),
+                    "icon": page.get("icon", ""),
+                }
+                page_config = {"content_padding": page.get("content_padding", "p-8")}
+                break
+
+    return header_config, page_config
+
+
+# Clientside callback to apply content padding class to main content container
+clientside_callback(
+    r"""
+    function(page_config) {
+        if (page_config && page_config.content_padding) {
+            const element = document.getElementById('main-content-container');
+            if (element) {
+                element.className = element.className.replace(/p-\d+|p-0/g, '');
+                element.className = element.className + ' ' + page_config.content_padding;
+            }
+        }
+        return window.dash_clientside.no_update;
+    }
+    """,
+    Output("main-content-container", "className"),
+    Input("page_config", "data"),
+    prevent_initial_call=False,
+)

src/dashkit/logo.py

@@ -70,7 +70,7 @@ def BrandHeader(brand_name, icon=None, subtitle=None):
 
     if icon:
         # Check if icon is a dash_iconify icon name (contains ':') or emoji/text
-        if ':' in icon:
+        if ":" in icon:
             header_content.append(
                 dash_iconify.DashIconify(
                     icon=icon,

src/dashkit/markdown_report.py

@@ -12,17 +12,17 @@ def MarkdownReport(
 
     Args:
         content: Markdown content to render
-        title: Optional title rendered within the report body and used in header
+        title: Optional title rendered within the report body
         className: Additional CSS classes
 
     Returns:
         html.Div: Styled markdown report component
     """
     children: list[Any] = []
 
-    # If title provided, use it to update header via Store consumed by header
+    # Render title inside the markdown when provided (header is managed globally)
     if title:
-        children.append(dcc.Store(id="page_header_config", data={"title": title}))
+        children.append(html.H1(title))
 
     children.append(
         dcc.Markdown(content, className="prose prose-sm dark:prose-invert max-w-none")