dash-startup-loading-plugin 0.1.0__tar.gz → 0.3.0__tar.gz

{dash_startup_loading_plugin-0.1.0/src/dash_startup_loading_plugin.egg-info → dash_startup_loading_plugin-0.3.0}/PKG-INFO

@@ -1,17 +1,19 @@
 Metadata-Version: 2.4
 Name: dash-startup-loading-plugin
-Version: 0.1.0
+Version: 0.3.0
 Summary: A configurable full-screen startup loading overlay for Dash apps, packaged as a Dash Hooks plugin.
 Author-email: Ethan Zhang <ethan.zhang2016@gmail.com>
 License-Expression: MIT
-Keywords: dash,plotly,loading,plugin,hooks
+Keywords: dash,plotly,loading,plugin
 Classifier: Framework :: Dash
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dash>=3.0.3
+Requires-Dist: dash==4.4.1
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
+Provides-Extra: mantine
+Requires-Dist: dash-mantine-components>=2.6.0; extra == "mantine"
 Dynamic: license-file
 
 # dash-startup-loading-plugin
@@ -20,10 +22,10 @@ Dynamic: license-file
 that displays a full-screen loading overlay while a Dash application performs
 its initial browser-side startup.
 
-The overlay is injected into the final HTML document with `hooks.index`, so it
-is visible before Dash and React mount the application layout. The packaged CSS
-and JavaScript are registered with `hooks.stylesheet` and `hooks.script`; an app
-does not need to copy assets or replace Dash's `index_string`.
+The overlay, CSS, and JavaScript are injected into the final HTML document with
+`hooks.index`, so they are available before Dash and React mount the application
+layout without additional startup resource requests. An app does not need to
+copy assets or replace Dash's `index_string`.
 
 ## Features
 
@@ -32,8 +34,10 @@ does not need to copy assets or replace Dash's `index_string`.
 - Waits for real rendered content and optional app-specific readiness selectors.
 - Can wait for lazy-loading placeholders to disappear.
 - Includes a timeout fallback, minimum display time, and fade-out transition.
-- Supports light and dark themes, reduced-motion preferences, custom colors,
-  custom spinner geometry, and trusted custom loader markup.
+- Inlines its small startup CSS and JavaScript, avoiding two additional requests.
+- Resolves light and dark themes before first paint from Dash component
+  persistence, Tailwind root classes, Mantine color-scheme state, or the
+  operating-system preference.
 - Exposes a small browser API and emits a completion event.
 - Requires no changes to the app layout or callbacks.
 
@@ -49,7 +53,7 @@ discovery, resource hooks, and the index hook described in the official
 ## Installation
 
 ```bash
-pip install dash-startup-loading-plugin
+pip install "dash-startup-loading-plugin>=0.3.0"
 ```
 
 The package declares the following entry point:
@@ -64,6 +68,27 @@ package therefore enables the default startup overlay for Dash applications in
 that Python environment; an explicit import is only needed when changing its
 configuration or using its Python API.
 
+## What's new in 0.3.0
+
+- Adds `configure_antd()` with matching `#ffffff` and `#121212` loading
+  backgrounds plus explicit light/dark overrides.
+- Adds `configure_mantine()` with theme defaults sourced from Dash Mantine
+  Components and its pre-render color-scheme hook.
+- Updates the Dash Ant Design example for the structured
+  `ConfigProvider.theme.algorithm` API.
+- Adds a Dash Mantine Components example with persisted theme switching.
+
+## What's new in 0.2.0
+
+- Resolves the loading background before first paint from a persisted
+  `dash_antd_components.ConfigProvider.theme`.
+- Supports Tailwind's `html.dark` and `html.light` classes.
+- Supports Dash Mantine Components' `data-mantine-color-scheme` attribute and
+  `mantine-color-scheme-value` localStorage entry.
+- Adds `theme_mode` and `dash_theme_component_id` configuration.
+- Keeps the startup CSS and JavaScript inline, so theme detection does not add
+  network requests before Dash mounts.
+
 ## Quick start
 
 The defaults work without any plugin-specific code:
@@ -91,25 +116,33 @@ from dash import Dash, html
 from dash_startup_loading_plugin import configure
 
 configure(
-    required_selectors=["#page-header", "#sidebar-menu"],
+    required_selectors=["#usage-header", "#usage-sidebar-menu"],
     pending_selector="[data-dac-async-placeholder]",
     timeout_ms=6000,
-    minimum_display_ms=200,
     fade_duration_ms=160,
-    color="#1677ff",
-    dark_color="#4096ff",
 )
 
 app = Dash(__name__)
 app.layout = html.Div(
     [
-        html.Header("Dashboard", id="page-header"),
-        html.Nav("Navigation", id="sidebar-menu"),
+        html.Header("Dashboard", id="usage-header"),
+        html.Nav("Navigation", id="usage-sidebar-menu"),
     ]
 )
 ```
 
-See [`examples/basic.py`](examples/basic.py) for a runnable example.
+Runnable examples:
+
+- [`examples/basic.py`](examples/basic.py): Dash Ant Design theme persistence.
+- [`examples/mantine_theme.py`](examples/mantine_theme.py):
+  Dash Mantine Components with a persisted light/dark theme switch.
+
+Run the Mantine example with:
+
+```bash
+pip install -e ".[mantine]"
+python examples/mantine_theme.py
+```
 
 ## Readiness behavior
 
@@ -152,14 +185,133 @@ immutable `StartupLoadingConfig` instance.
 | `dark_background` | `"#0f0f0f"` | Dark-theme background color. |
 | `color` | `"#1677ff"` | Light-theme spinner/current color. |
 | `dark_color` | `"#4096ff"` | Dark-theme spinner/current color. |
+| `theme_mode` | `"auto"` | Startup theme policy: `"auto"`, `"light"`, or `"dark"`. Auto follows persisted or active app state, then the operating-system preference. |
+| `dash_theme_component_id` | `None` | Preferred Dash component ID when reading a persisted `theme` prop. When omitted, the first compatible persisted theme is used. |
 | `spinner_size_px` | `28` | Default spinner width and height in pixels. |
 | `spinner_stroke_px` | `3` | Default spinner stroke width in pixels. |
 | `hide_default_loading` | `True` | Hide Dash's built-in initial `._dash-loading` indicator while the overlay is present. |
 | `custom_loader_html` | `None` | Trusted HTML that replaces the default spinner. |
 
-The default stylesheet recognizes `html.dark` and `html.light`. When neither
-class forces a theme, it follows `prefers-color-scheme`. It also adjusts its
-animation when the user enables `prefers-reduced-motion`.
+With `theme_mode="auto"`, the inline head bootstrap resolves the startup theme
+in this order:
+
+1. The persisted Dash `theme` for `dash_theme_component_id`, when configured.
+2. An existing `html.dark` or `html.light` class, including Tailwind's manual
+   dark-mode convention.
+3. `data-theme`, `data-color-scheme`, or `data-mantine-color-scheme` on
+   `<html>`.
+4. Other Dash local persistence entries for a component's `theme` prop. Set
+   `dash_theme_component_id` when an app contains more than one persisted
+   theme-capable component.
+5. Dash Mantine Components' `mantine-color-scheme-value` localStorage entry,
+   followed by the common `theme`, `color-theme`, and `color-scheme` keys.
+6. `prefers-color-scheme`.
+
+The result is written to `data-dash-startup-loading-theme` before the body is
+parsed. This isolates the overlay styling without changing classes or data
+attributes owned by Tailwind, Dash Mantine Components, or the application.
+The stylesheet also adjusts its animation for `prefers-reduced-motion`.
+
+### Dash Mantine Components
+
+Dash Mantine Components 2.6 and later includes `ColorSchemeToggle`, which
+switches the active color scheme without a callback and persists it in
+`mantine-color-scheme-value`. The startup plugin reads that value before Dash
+and React mount. To make the loading transition seamless, use Mantine's current
+default dark body color for the overlay:
+
+```python
+import dash_mantine_components as dmc
+from dash_startup_loading_plugin import configure_mantine
+
+configure_mantine()
+
+app.layout = dmc.MantineProvider(
+    [
+        dmc.ColorSchemeToggle(
+            lightIcon=dmc.Text("☀"),
+            darkIcon=dmc.Text("☾"),
+        ),
+        dmc.Text("Application content", id="app-ready"),
+    ],
+    defaultColorScheme="auto",
+)
+```
+
+See
+[`examples/mantine_theme.py`](examples/mantine_theme.py)
+for the complete runnable example.
+
+`configure_mantine()` keeps DMC optional. When used, it registers DMC's
+pre-render color-scheme hook, disables the Dash Ant Design placeholder check,
+and derives the light and dark loading backgrounds from DMC's active default
+theme. Any explicit configuration still takes precedence:
+
+```python
+configure_mantine(dark_background="#202020")
+```
+
+### Dash Ant Design persistence
+
+Current `dash_antd_components.ConfigProvider.theme` accepts a structured theme
+configuration whose `algorithm` is `"default"`, `"dark"`, `"compact"`, or an
+array of those values. Persist a user-facing system/light/dark selector, resolve
+the system preference in a clientside callback, and store the semantic choice
+in the small conventional `localStorage["theme"]` value that the startup plugin
+reads before Dash mounts:
+
+```python
+import dash_antd_components as dac
+from dash import Input, Output, clientside_callback
+from dash_startup_loading_plugin import configure_antd
+
+configure_antd()
+
+provider = dac.ConfigProvider(
+    [
+        app_content,
+        dac.Segmented(
+            id="theme-mode",
+            options=["system", "light", "dark"],
+            value="system",
+            persistence=True,
+            persisted_props=["value"],
+            persistence_type="local",
+        ),
+    ],
+    id="theme-provider",
+    theme={"algorithm": "default"},
+)
+
+clientside_callback(
+    """function(mode) {
+        localStorage.setItem("theme", JSON.stringify(mode));
+        const dark = mode === "dark" || (
+            mode === "system"
+            && window.matchMedia("(prefers-color-scheme: dark)").matches
+        );
+        return {algorithm: dark ? "dark" : "default"};
+    }""",
+    Output("theme-provider", "theme"),
+    Input("theme-mode", "value"),
+)
+```
+
+The selector owns the semantic `"system"` state; `ConfigProvider` receives only
+the algorithms allowed by its current API. `configure_antd()` uses `#ffffff`
+and `#121212`, matching the component library's default light and dark
+backgrounds. If the application customizes either background, pass the same
+values explicitly:
+
+```python
+configure_antd(
+    background="#f5f5f5",
+    dark_background="#202020",
+)
+```
+
+See
+[`examples/basic.py`](examples/basic.py) for the complete switcher.
 
 ### Custom loader markup
 
@@ -186,12 +338,18 @@ configuration. Never populate it with user input.
 from dash_startup_loading_plugin import (
     StartupLoadingConfig,
     configure,
+    configure_antd,
+    configure_mantine,
     get_config,
     reset_config,
 )
 ```
 
 - `configure(**changes)` validates and applies a partial configuration update.
+- `configure_antd(**changes)` matches the loading backgrounds to Dash Ant
+  Design's light and dark themes and accepts explicit overrides.
+- `configure_mantine(**changes)` applies DMC theme defaults and registers DMC's
+  pre-render color-scheme hook.
 - `get_config()` returns the current immutable configuration.
 - `reset_config()` restores all defaults. It is primarily useful in tests.
 - `StartupLoadingConfig` is the frozen dataclass containing all options.
@@ -241,11 +399,18 @@ configure(
 )
 ```
 
-The plugin preserves Dash's normal index template, injects the overlay directly
-after the opening `<body>` tag, and registers its versioned package assets via
-Dash Hooks. The index hook uses priority `100`, so it runs before lower-priority
-index hooks. If multiple hooks share the same priority, Dash does not guarantee
-their relative order.
+The plugin preserves Dash's normal index template, injects its stylesheet before
+`</head>`, and inserts the overlay followed by its startup script directly after
+the opening `<body>` tag. The source CSS and JavaScript remain package resources
+for maintainability, but the browser receives them inline and makes no separate
+request for either file. The index hook uses priority `100`, so it runs before
+lower-priority index hooks. If multiple hooks share the same priority, Dash does
+not guarantee their relative order.
+
+Because the resources are inline, applications with a strict Content Security
+Policy must permit the injected style and script, or add nonce support in a
+customized deployment. The previous external-resource form is more suitable
+when a policy forbids all inline code.
 
 ## Scope and process model
 
@@ -282,27 +447,6 @@ This is expected with automatic `dash_hooks` discovery. Use a dedicated virtual
 environment, uninstall the package where it is not wanted, or call
 `configure(enabled=False)` before constructing those Dash apps.
 
-## Development
-
-Clone the repository, then install the project and test dependencies:
-
-```bash
-uv sync --extra test
-```
-
-Run the tests and example:
-
-```bash
-uv run pytest
-uv run python examples/basic.py
-```
-
-Build the source distribution and wheel:
-
-```bash
-uv build
-```
-
 ## License
 
 MIT. See [`LICENSE`](LICENSE).

{dash_startup_loading_plugin-0.1.0 → dash_startup_loading_plugin-0.3.0}/README.md

@@ -4,10 +4,10 @@
 that displays a full-screen loading overlay while a Dash application performs
 its initial browser-side startup.
 
-The overlay is injected into the final HTML document with `hooks.index`, so it
-is visible before Dash and React mount the application layout. The packaged CSS
-and JavaScript are registered with `hooks.stylesheet` and `hooks.script`; an app
-does not need to copy assets or replace Dash's `index_string`.
+The overlay, CSS, and JavaScript are injected into the final HTML document with
+`hooks.index`, so they are available before Dash and React mount the application
+layout without additional startup resource requests. An app does not need to
+copy assets or replace Dash's `index_string`.
 
 ## Features
 
@@ -16,8 +16,10 @@ does not need to copy assets or replace Dash's `index_string`.
 - Waits for real rendered content and optional app-specific readiness selectors.
 - Can wait for lazy-loading placeholders to disappear.
 - Includes a timeout fallback, minimum display time, and fade-out transition.
-- Supports light and dark themes, reduced-motion preferences, custom colors,
-  custom spinner geometry, and trusted custom loader markup.
+- Inlines its small startup CSS and JavaScript, avoiding two additional requests.
+- Resolves light and dark themes before first paint from Dash component
+  persistence, Tailwind root classes, Mantine color-scheme state, or the
+  operating-system preference.
 - Exposes a small browser API and emits a completion event.
 - Requires no changes to the app layout or callbacks.
 
@@ -33,7 +35,7 @@ discovery, resource hooks, and the index hook described in the official
 ## Installation
 
 ```bash
-pip install dash-startup-loading-plugin
+pip install "dash-startup-loading-plugin>=0.3.0"
 ```
 
 The package declares the following entry point:
@@ -48,6 +50,27 @@ package therefore enables the default startup overlay for Dash applications in
 that Python environment; an explicit import is only needed when changing its
 configuration or using its Python API.
 
+## What's new in 0.3.0
+
+- Adds `configure_antd()` with matching `#ffffff` and `#121212` loading
+  backgrounds plus explicit light/dark overrides.
+- Adds `configure_mantine()` with theme defaults sourced from Dash Mantine
+  Components and its pre-render color-scheme hook.
+- Updates the Dash Ant Design example for the structured
+  `ConfigProvider.theme.algorithm` API.
+- Adds a Dash Mantine Components example with persisted theme switching.
+
+## What's new in 0.2.0
+
+- Resolves the loading background before first paint from a persisted
+  `dash_antd_components.ConfigProvider.theme`.
+- Supports Tailwind's `html.dark` and `html.light` classes.
+- Supports Dash Mantine Components' `data-mantine-color-scheme` attribute and
+  `mantine-color-scheme-value` localStorage entry.
+- Adds `theme_mode` and `dash_theme_component_id` configuration.
+- Keeps the startup CSS and JavaScript inline, so theme detection does not add
+  network requests before Dash mounts.
+
 ## Quick start
 
 The defaults work without any plugin-specific code:
@@ -75,25 +98,33 @@ from dash import Dash, html
 from dash_startup_loading_plugin import configure
 
 configure(
-    required_selectors=["#page-header", "#sidebar-menu"],
+    required_selectors=["#usage-header", "#usage-sidebar-menu"],
     pending_selector="[data-dac-async-placeholder]",
     timeout_ms=6000,
-    minimum_display_ms=200,
     fade_duration_ms=160,
-    color="#1677ff",
-    dark_color="#4096ff",
 )
 
 app = Dash(__name__)
 app.layout = html.Div(
     [
-        html.Header("Dashboard", id="page-header"),
-        html.Nav("Navigation", id="sidebar-menu"),
+        html.Header("Dashboard", id="usage-header"),
+        html.Nav("Navigation", id="usage-sidebar-menu"),
     ]
 )
 ```
 
-See [`examples/basic.py`](examples/basic.py) for a runnable example.
+Runnable examples:
+
+- [`examples/basic.py`](examples/basic.py): Dash Ant Design theme persistence.
+- [`examples/mantine_theme.py`](examples/mantine_theme.py):
+  Dash Mantine Components with a persisted light/dark theme switch.
+
+Run the Mantine example with:
+
+```bash
+pip install -e ".[mantine]"
+python examples/mantine_theme.py
+```
 
 ## Readiness behavior
 
@@ -136,14 +167,133 @@ immutable `StartupLoadingConfig` instance.
 | `dark_background` | `"#0f0f0f"` | Dark-theme background color. |
 | `color` | `"#1677ff"` | Light-theme spinner/current color. |
 | `dark_color` | `"#4096ff"` | Dark-theme spinner/current color. |
+| `theme_mode` | `"auto"` | Startup theme policy: `"auto"`, `"light"`, or `"dark"`. Auto follows persisted or active app state, then the operating-system preference. |
+| `dash_theme_component_id` | `None` | Preferred Dash component ID when reading a persisted `theme` prop. When omitted, the first compatible persisted theme is used. |
 | `spinner_size_px` | `28` | Default spinner width and height in pixels. |
 | `spinner_stroke_px` | `3` | Default spinner stroke width in pixels. |
 | `hide_default_loading` | `True` | Hide Dash's built-in initial `._dash-loading` indicator while the overlay is present. |
 | `custom_loader_html` | `None` | Trusted HTML that replaces the default spinner. |
 
-The default stylesheet recognizes `html.dark` and `html.light`. When neither
-class forces a theme, it follows `prefers-color-scheme`. It also adjusts its
-animation when the user enables `prefers-reduced-motion`.
+With `theme_mode="auto"`, the inline head bootstrap resolves the startup theme
+in this order:
+
+1. The persisted Dash `theme` for `dash_theme_component_id`, when configured.
+2. An existing `html.dark` or `html.light` class, including Tailwind's manual
+   dark-mode convention.
+3. `data-theme`, `data-color-scheme`, or `data-mantine-color-scheme` on
+   `<html>`.
+4. Other Dash local persistence entries for a component's `theme` prop. Set
+   `dash_theme_component_id` when an app contains more than one persisted
+   theme-capable component.
+5. Dash Mantine Components' `mantine-color-scheme-value` localStorage entry,
+   followed by the common `theme`, `color-theme`, and `color-scheme` keys.
+6. `prefers-color-scheme`.
+
+The result is written to `data-dash-startup-loading-theme` before the body is
+parsed. This isolates the overlay styling without changing classes or data
+attributes owned by Tailwind, Dash Mantine Components, or the application.
+The stylesheet also adjusts its animation for `prefers-reduced-motion`.
+
+### Dash Mantine Components
+
+Dash Mantine Components 2.6 and later includes `ColorSchemeToggle`, which
+switches the active color scheme without a callback and persists it in
+`mantine-color-scheme-value`. The startup plugin reads that value before Dash
+and React mount. To make the loading transition seamless, use Mantine's current
+default dark body color for the overlay:
+
+```python
+import dash_mantine_components as dmc
+from dash_startup_loading_plugin import configure_mantine
+
+configure_mantine()
+
+app.layout = dmc.MantineProvider(
+    [
+        dmc.ColorSchemeToggle(
+            lightIcon=dmc.Text("☀"),
+            darkIcon=dmc.Text("☾"),
+        ),
+        dmc.Text("Application content", id="app-ready"),
+    ],
+    defaultColorScheme="auto",
+)
+```
+
+See
+[`examples/mantine_theme.py`](examples/mantine_theme.py)
+for the complete runnable example.
+
+`configure_mantine()` keeps DMC optional. When used, it registers DMC's
+pre-render color-scheme hook, disables the Dash Ant Design placeholder check,
+and derives the light and dark loading backgrounds from DMC's active default
+theme. Any explicit configuration still takes precedence:
+
+```python
+configure_mantine(dark_background="#202020")
+```
+
+### Dash Ant Design persistence
+
+Current `dash_antd_components.ConfigProvider.theme` accepts a structured theme
+configuration whose `algorithm` is `"default"`, `"dark"`, `"compact"`, or an
+array of those values. Persist a user-facing system/light/dark selector, resolve
+the system preference in a clientside callback, and store the semantic choice
+in the small conventional `localStorage["theme"]` value that the startup plugin
+reads before Dash mounts:
+
+```python
+import dash_antd_components as dac
+from dash import Input, Output, clientside_callback
+from dash_startup_loading_plugin import configure_antd
+
+configure_antd()
+
+provider = dac.ConfigProvider(
+    [
+        app_content,
+        dac.Segmented(
+            id="theme-mode",
+            options=["system", "light", "dark"],
+            value="system",
+            persistence=True,
+            persisted_props=["value"],
+            persistence_type="local",
+        ),
+    ],
+    id="theme-provider",
+    theme={"algorithm": "default"},
+)
+
+clientside_callback(
+    """function(mode) {
+        localStorage.setItem("theme", JSON.stringify(mode));
+        const dark = mode === "dark" || (
+            mode === "system"
+            && window.matchMedia("(prefers-color-scheme: dark)").matches
+        );
+        return {algorithm: dark ? "dark" : "default"};
+    }""",
+    Output("theme-provider", "theme"),
+    Input("theme-mode", "value"),
+)
+```
+
+The selector owns the semantic `"system"` state; `ConfigProvider` receives only
+the algorithms allowed by its current API. `configure_antd()` uses `#ffffff`
+and `#121212`, matching the component library's default light and dark
+backgrounds. If the application customizes either background, pass the same
+values explicitly:
+
+```python
+configure_antd(
+    background="#f5f5f5",
+    dark_background="#202020",
+)
+```
+
+See
+[`examples/basic.py`](examples/basic.py) for the complete switcher.
 
 ### Custom loader markup
 
@@ -170,12 +320,18 @@ configuration. Never populate it with user input.
 from dash_startup_loading_plugin import (
     StartupLoadingConfig,
     configure,
+    configure_antd,
+    configure_mantine,
     get_config,
     reset_config,
 )
 ```
 
 - `configure(**changes)` validates and applies a partial configuration update.
+- `configure_antd(**changes)` matches the loading backgrounds to Dash Ant
+  Design's light and dark themes and accepts explicit overrides.
+- `configure_mantine(**changes)` applies DMC theme defaults and registers DMC's
+  pre-render color-scheme hook.
 - `get_config()` returns the current immutable configuration.
 - `reset_config()` restores all defaults. It is primarily useful in tests.
 - `StartupLoadingConfig` is the frozen dataclass containing all options.
@@ -225,11 +381,18 @@ configure(
 )
 ```
 
-The plugin preserves Dash's normal index template, injects the overlay directly
-after the opening `<body>` tag, and registers its versioned package assets via
-Dash Hooks. The index hook uses priority `100`, so it runs before lower-priority
-index hooks. If multiple hooks share the same priority, Dash does not guarantee
-their relative order.
+The plugin preserves Dash's normal index template, injects its stylesheet before
+`</head>`, and inserts the overlay followed by its startup script directly after
+the opening `<body>` tag. The source CSS and JavaScript remain package resources
+for maintainability, but the browser receives them inline and makes no separate
+request for either file. The index hook uses priority `100`, so it runs before
+lower-priority index hooks. If multiple hooks share the same priority, Dash does
+not guarantee their relative order.
+
+Because the resources are inline, applications with a strict Content Security
+Policy must permit the injected style and script, or add nonce support in a
+customized deployment. The previous external-resource form is more suitable
+when a policy forbids all inline code.
 
 ## Scope and process model
 
@@ -266,27 +429,6 @@ This is expected with automatic `dash_hooks` discovery. Use a dedicated virtual
 environment, uninstall the package where it is not wanted, or call
 `configure(enabled=False)` before constructing those Dash apps.
 
-## Development
-
-Clone the repository, then install the project and test dependencies:
-
-```bash
-uv sync --extra test
-```
-
-Run the tests and example:
-
-```bash
-uv run pytest
-uv run python examples/basic.py
-```
-
-Build the source distribution and wheel:
-
-```bash
-uv build
-```
-
 ## License
 
 MIT. See [`LICENSE`](LICENSE).

{dash_startup_loading_plugin-0.1.0 → dash_startup_loading_plugin-0.3.0}/pyproject.toml

@@ -4,25 +4,28 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dash-startup-loading-plugin"
-version = "0.1.0"
+version = "0.3.0"
 description = "A configurable full-screen startup loading overlay for Dash apps, packaged as a Dash Hooks plugin."
 readme = "README.md"
 requires-python = ">=3.9"
 authors = [
       { name = "Ethan Zhang", email = "ethan.zhang2016@gmail.com" }
 ]
-keywords = ["dash", "plotly", "loading", "plugin", "hooks"]
+keywords = ["dash", "plotly", "loading", "plugin"]
 classifiers = ["Framework :: Dash"]
 license = "MIT"
 license-files = ["LICENSE"]
 dependencies = [
-    "dash>=3.0.3",
+    "dash==4.4.1",
 ]
 
 [project.optional-dependencies]
 test = [
     "pytest>=8",
 ]
+mantine = [
+    "dash-mantine-components>=2.6.0",
+]
 
 [project.entry-points."dash_hooks"]
 dash_startup_loading_plugin = "dash_startup_loading_plugin"