starlette-admin-infinite-scroll 0.1.0__tar.gz

starlette_admin_infinite_scroll-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.venv/
+venv/
+dist/
+build/
+*.sqlite
+*.sqlite3
+.coverage
+htmlcov/
+.env

starlette_admin_infinite_scroll-0.1.0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project
+adheres to [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-29
+
+### Added
+
+- `InfiniteScrollPlugin` for starlette-admin 1.0: appends the next list page
+  when the bottom of the table approaches the viewport.
+- Options: `views`, `exclude_views`, `root_margin`, `hide_pagination`,
+  `max_auto_pages`.
+- "Load more" fallback, retry on error, duplicate-row protection, and support
+  for selection, row actions, tooltips, JSON viewers and search highlighting
+  on appended rows.
+- `sa:infinite-scroll:rows-appended` DOM event and
+  `window.StarletteAdmin.infiniteScroll` JavaScript API.
+
+[Unreleased]: https://github.com/Alwinator/starlette-admin-infinite-scroll/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/Alwinator/starlette-admin-infinite-scroll/releases/tag/v0.1.0

starlette_admin_infinite_scroll-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alwin J. Schuster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

starlette_admin_infinite_scroll-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.5
+Name: starlette-admin-infinite-scroll
+Version: 0.1.0
+Summary: Infinite scrolling for the starlette-admin list view
+Project-URL: Homepage, https://github.com/Alwinator/starlette-admin-infinite-scroll
+Project-URL: Repository, https://github.com/Alwinator/starlette-admin-infinite-scroll
+Project-URL: Documentation, https://github.com/Alwinator/starlette-admin-infinite-scroll/blob/main/docs/index.md
+Project-URL: Issues, https://github.com/Alwinator/starlette-admin-infinite-scroll/issues
+Project-URL: Changelog, https://github.com/Alwinator/starlette-admin-infinite-scroll/blob/main/CHANGELOG.md
+Author-email: "Alwin J. Schuster" <contact@alwinschuster.at>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: admin,fastapi,infinite-scroll,plugin,starlette,starlette-admin
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: JavaScript
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: starlette-admin>=1.0
+Provides-Extra: i18n
+Requires-Dist: babel>=2.17.0; extra == 'i18n'
+Description-Content-Type: text/markdown
+
+# starlette-admin-infinite-scroll
+
+[![CI](https://github.com/Alwinator/starlette-admin-infinite-scroll/actions/workflows/ci.yml/badge.svg)](https://github.com/Alwinator/starlette-admin-infinite-scroll/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/starlette-admin-infinite-scroll.svg)](https://pypi.org/project/starlette-admin-infinite-scroll/)
+[![Python versions](https://img.shields.io/pypi/pyversions/starlette-admin-infinite-scroll.svg)](https://pypi.org/project/starlette-admin-infinite-scroll/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Infinite scrolling for the [starlette-admin](https://github.com/jowilf/starlette-admin)
+list view.
+
+Scroll to the bottom of a list and the next page is appended to the table,
+keeping the current search, sort, filters, visible columns and page size.
+Appended rows are rendered by starlette-admin itself, so selection, bulk and
+row actions, row click navigation and inline editing keep working.
+
+## Install
+
+```bash
+pip install starlette-admin-infinite-scroll
+```
+
+Requires Python 3.11+ and starlette-admin 1.0+.
+
+## Usage
+
+```python
+from starlette_admin.contrib.sqla import Admin
+from starlette_admin_infinite_scroll import InfiniteScrollPlugin
+
+admin = Admin(engine, plugins=[InfiniteScrollPlugin()])
+```
+
+Configure it through the constructor:
+
+```python
+InfiniteScrollPlugin(
+    views=["product", "order"],  # only these list views (default: all)
+    exclude_views=["audit-log"], # keep these paginated
+    root_margin="600px",         # start loading earlier (default: "400px")
+    hide_pagination=True,        # hide page links (default: True)
+    max_auto_pages=5,            # then show "Load more" (default: 0 = unlimited)
+)
+```
+
+See [docs/index.md](docs/index.md) for details, behavior notes and the
+JavaScript API.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run python example/app.py  # demo at http://localhost:8000/admin/product/list
+```
+
+`make lint`, `make format`, `make test` and `make build` wrap the usual tasks.
+
+## Releasing
+
+1. Bump `__version__` in `src/starlette_admin_infinite_scroll/__init__.py`
+   and add an entry to [CHANGELOG.md](CHANGELOG.md).
+2. Commit and push to `main`.
+3. Create a GitHub release with the tag `v<version>` (e.g. `v0.2.0`).
+
+Publishing the release runs [`publish.yml`](.github/workflows/publish.yml):
+CI, a check that the tag matches the package version, the build, the upload
+to PyPI via Trusted Publishing, and attaching the built files to the release.
+
+## License
+
+[MIT](LICENSE)

starlette_admin_infinite_scroll-0.1.0/README.md

@@ -0,0 +1,71 @@
+# starlette-admin-infinite-scroll
+
+[![CI](https://github.com/Alwinator/starlette-admin-infinite-scroll/actions/workflows/ci.yml/badge.svg)](https://github.com/Alwinator/starlette-admin-infinite-scroll/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/starlette-admin-infinite-scroll.svg)](https://pypi.org/project/starlette-admin-infinite-scroll/)
+[![Python versions](https://img.shields.io/pypi/pyversions/starlette-admin-infinite-scroll.svg)](https://pypi.org/project/starlette-admin-infinite-scroll/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Infinite scrolling for the [starlette-admin](https://github.com/jowilf/starlette-admin)
+list view.
+
+Scroll to the bottom of a list and the next page is appended to the table,
+keeping the current search, sort, filters, visible columns and page size.
+Appended rows are rendered by starlette-admin itself, so selection, bulk and
+row actions, row click navigation and inline editing keep working.
+
+## Install
+
+```bash
+pip install starlette-admin-infinite-scroll
+```
+
+Requires Python 3.11+ and starlette-admin 1.0+.
+
+## Usage
+
+```python
+from starlette_admin.contrib.sqla import Admin
+from starlette_admin_infinite_scroll import InfiniteScrollPlugin
+
+admin = Admin(engine, plugins=[InfiniteScrollPlugin()])
+```
+
+Configure it through the constructor:
+
+```python
+InfiniteScrollPlugin(
+    views=["product", "order"],  # only these list views (default: all)
+    exclude_views=["audit-log"], # keep these paginated
+    root_margin="600px",         # start loading earlier (default: "400px")
+    hide_pagination=True,        # hide page links (default: True)
+    max_auto_pages=5,            # then show "Load more" (default: 0 = unlimited)
+)
+```
+
+See [docs/index.md](docs/index.md) for details, behavior notes and the
+JavaScript API.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run python example/app.py  # demo at http://localhost:8000/admin/product/list
+```
+
+`make lint`, `make format`, `make test` and `make build` wrap the usual tasks.
+
+## Releasing
+
+1. Bump `__version__` in `src/starlette_admin_infinite_scroll/__init__.py`
+   and add an entry to [CHANGELOG.md](CHANGELOG.md).
+2. Commit and push to `main`.
+3. Create a GitHub release with the tag `v<version>` (e.g. `v0.2.0`).
+
+Publishing the release runs [`publish.yml`](.github/workflows/publish.yml):
+CI, a check that the tag matches the package version, the build, the upload
+to PyPI via Trusted Publishing, and attaching the built files to the release.
+
+## License
+
+[MIT](LICENSE)

starlette_admin_infinite_scroll-0.1.0/docs/index.md

@@ -0,0 +1,92 @@
+# Infinite Scroll
+
+Infinite scrolling for the starlette-admin list view.
+
+When the bottom of a list table approaches the viewport, the next page is
+fetched from the regular list route (keeping the current search, sort,
+filters, visible columns and page size) and its rows are appended to the
+table. No extra endpoint is involved: rows are rendered by core's own
+`_list_row.html`, so they look and behave exactly like server-rendered ones
+(row selection, bulk and row actions, row click navigation, inline edit,
+tooltips, JSON viewers, search highlighting).
+
+## Install
+
+```bash
+pip install starlette-admin-infinite-scroll
+```
+
+## Usage
+
+```python
+from starlette_admin_infinite_scroll import InfiniteScrollPlugin
+from starlette_admin.contrib.sqla import Admin
+
+admin = Admin(engine, plugins=[InfiniteScrollPlugin()])
+```
+
+That is the only integration point. Options are passed straight to the
+constructor:
+
+```python
+InfiniteScrollPlugin(
+    views=["product", "order"],  # only these list views
+    root_margin="600px",         # start loading earlier
+    max_auto_pages=5,            # then show a "Load more" button
+)
+```
+
+## Options
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `views` | `None` | Identities of the model views that get infinite scrolling. `None` enables it on every list view. |
+| `exclude_views` | `()` | Identities of model views to leave paginated, applied after `views`. |
+| `root_margin` | `"400px"` | How close the bottom of the table must be to the viewport before the next page is requested. |
+| `hide_pagination` | `True` | Hide the page links and the "go to page" form. The "Showing x to y of z" summary (kept up to date) and the page size selector stay. |
+| `max_auto_pages` | `0` | Pages loaded automatically before switching to a "Load more" button. `0` means unlimited. |
+
+The page size selector keeps working: pick a bigger page size to load more
+rows per request. With "All", everything is on the first page and the plugin
+stays idle.
+
+## Behavior notes
+
+- Scripts and styles are only injected on list pages of enabled views.
+- Pages that do not fill the viewport keep loading until they do.
+- Rows already displayed (for example after rows were created while
+  scrolling) are skipped, so a pk is never shown twice.
+- When "select all" is checked, appended rows are selected too, so the
+  "select all matching" state stays consistent.
+- A failed request shows an error with a "Retry" button.
+- Reloading the page, or coming back from a detail page, starts over at the
+  page in the URL.
+
+## JavaScript API
+
+The instance is exposed as `window.StarletteAdmin.infiniteScroll`
+(`loadNext()`, `currentPage`, `totalPages`). After each batch the card
+element dispatches a bubbling `sa:infinite-scroll:rows-appended` event with
+`detail.rows` (the appended `<tr>` elements) and `detail.page`, so custom list
+templates can bind their own widgets:
+
+```js
+document.addEventListener("sa:infinite-scroll:rows-appended", (e) => {
+  e.detail.rows.forEach(initMyWidgets);
+});
+```
+
+## Overriding assets
+
+Every file this plugin ships lives under `plugins/infinite-scroll/`. Drop a
+file at the matching path under your own `static_dir` to override it:
+
+```
+your_project/
+└── static/
+    └── plugins/infinite-scroll/css/infinite-scroll.css
+```
+
+The status area uses the `.sa-infinite-scroll-status` class. The "Load more"
+and "Retry" buttons resolve their classes through the theme `ClassMap` roles
+`infinite_scroll.load_more_button` and `infinite_scroll.retry_button`.

starlette_admin_infinite_scroll-0.1.0/example/app.py

@@ -0,0 +1,81 @@
+"""Runnable demo for starlette-admin-infinite-scroll.
+
+Mounts a SQLite-backed SQLAlchemy admin seeded with 500 products and the plugin
+registered. Run `uv run python example/app.py` from the project root, then open
+http://localhost:8000/admin/product/list.
+"""
+
+from contextlib import asynccontextmanager
+
+import uvicorn
+from sqlalchemy import Integer, create_engine, func, select
+from sqlalchemy.orm import DeclarativeBase, Mapped, Session, mapped_column
+from starlette.applications import Starlette
+from starlette.responses import HTMLResponse
+from starlette.routing import Route
+from starlette_admin.contrib.sqla import Admin, ModelView
+
+from starlette_admin_infinite_scroll import InfiniteScrollPlugin
+
+engine = create_engine(
+    "sqlite:///example.sqlite", connect_args={"check_same_thread": False}
+)
+
+
+class Base(DeclarativeBase):
+    """Base class for all SQLAlchemy declarative models."""
+
+
+class Product(Base):
+    __tablename__ = "products"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    name: Mapped[str]
+
+
+class ProductView(ModelView):
+    fields = [
+        "id",
+        "name",
+    ]
+    searchable_fields = ["name"]
+
+
+@asynccontextmanager
+async def lifespan(app: Starlette):
+    Base.metadata.create_all(engine)
+    # Seed enough rows to scroll through several pages.
+    with Session(engine) as session:
+        if session.scalar(select(func.count(Product.id))) == 0:
+            session.add_all(Product(name=f"Product #{i:04d}") for i in range(1, 501))
+            session.commit()
+    yield
+
+
+app = Starlette(
+    lifespan=lifespan,
+    routes=[
+        Route(
+            "/",
+            lambda _: HTMLResponse('<a href="/admin/">Go to Admin &rarr;</a>'),
+        )
+    ],
+)
+
+admin = Admin(
+    engine,
+    title="Infinite Scroll demo",
+    secret_key="dev-only-change-me",
+    plugins=[InfiniteScrollPlugin(root_margin="300px", max_auto_pages=5)],
+    debug=True,
+)
+
+admin.add_view(ProductView(Product))
+
+admin.mount_to(app)
+
+
+if __name__ == "__main__":
+    # Pass the app object (not an "app:app" import string) so the script works
+    # from any working directory.
+    uvicorn.run(app, port=8000)

starlette_admin_infinite_scroll-0.1.0/pyproject.toml

@@ -0,0 +1,86 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "starlette-admin-infinite-scroll"
+description = "Infinite scrolling for the starlette-admin list view"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "Alwin J. Schuster", email = "contact@alwinschuster.at" }]
+keywords = ["starlette", "fastapi", "admin", "starlette-admin", "infinite-scroll", "plugin"]
+# Single source of truth: `__version__` in src/starlette_admin_infinite_scroll/__init__.py
+dynamic = ["version"]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Framework :: AsyncIO",
+    "Framework :: FastAPI",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: JavaScript",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+
+dependencies = [
+    "starlette-admin >=1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Alwinator/starlette-admin-infinite-scroll"
+Repository = "https://github.com/Alwinator/starlette-admin-infinite-scroll"
+Documentation = "https://github.com/Alwinator/starlette-admin-infinite-scroll/blob/main/docs/index.md"
+Issues = "https://github.com/Alwinator/starlette-admin-infinite-scroll/issues"
+Changelog = "https://github.com/Alwinator/starlette-admin-infinite-scroll/blob/main/CHANGELOG.md"
+
+[project.entry-points."starlette_admin.plugins"]
+infinite-scroll = "starlette_admin_infinite_scroll:InfiniteScrollPlugin"
+
+[project.optional-dependencies]
+i18n = ["babel>=2.17.0"]
+
+[tool.hatch.version]
+path = "src/starlette_admin_infinite_scroll/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/starlette_admin_infinite_scroll"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/",
+    "tests/",
+    "docs/",
+    "example/",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "httpx>=0.27",
+    "ruff>=0.8",
+    # starlette-admin's SQLAlchemy contrib targets 2.0.x.
+    "sqlalchemy[asyncio]>=2.0,<2.1",
+    "uvicorn[standard]>=0.30",
+]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

starlette_admin_infinite_scroll-0.1.0/src/starlette_admin_infinite_scroll/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.1.0"
+
+from .plugin import InfiniteScrollConfig as InfiniteScrollConfig
+from .plugin import InfiniteScrollPlugin as InfiniteScrollPlugin

starlette_admin_infinite_scroll-0.1.0/src/starlette_admin_infinite_scroll/plugin.py

@@ -0,0 +1,132 @@
+"""`InfiniteScrollPlugin`: The entry point end users list in `Admin(plugins=[...])`.
+
+The plugin is purely client side. On list pages it injects one script that
+watches the bottom of the list table and, when it scrolls into view, fetches
+the next page of the regular server-rendered list route
+(``/{key}/list?page=N``, keeping the current search/sort/filter/columns
+query params), extracts its ``<tr data-sa-pk>`` rows and appends them to the
+current table. No extra endpoint is needed: rows are rendered by the very
+same ``_list_row.html`` template core uses.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Sequence
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+from starlette.datastructures import URL
+from starlette.requests import Request
+from starlette_admin.helpers import static_url
+from starlette_admin.i18n import gettext as _
+from starlette_admin.plugins import BasePlugin
+from starlette_admin.types import RequestAction
+
+_VERSION = "1"
+
+
+@dataclass(frozen=True)
+class InfiniteScrollConfig:
+    """Options accepted by `InfiniteScrollPlugin(**options)`.
+
+    Attributes:
+        views: Identities (keys) of the model views that get infinite
+            scrolling. `None` (the default) enables it on every list view.
+        exclude_views: Identities of model views to leave untouched, applied
+            after `views`.
+        root_margin: `IntersectionObserver` root margin. The next page starts
+            loading when the bottom of the table is this close to the
+            viewport, so rows are usually ready before the user reaches them.
+        hide_pagination: Hide the page links and "go to page" form once
+            infinite scrolling is active. The "Showing x to y of z" summary and
+            the page size selector are kept.
+        max_auto_pages: Number of pages loaded automatically while scrolling
+            before switching to a "Load more" button. `0` means unlimited.
+    """
+
+    views: Sequence[str] | None = None
+    exclude_views: Sequence[str] = field(default_factory=tuple)
+    root_margin: str = "400px"
+    hide_pagination: bool = True
+    max_auto_pages: int = 0
+
+    def __post_init__(self) -> None:
+        if self.max_auto_pages < 0:
+            raise ValueError("max_auto_pages must be >= 0")
+        # Normalize to tuples so the frozen config stays immutable.
+        if self.views is not None:
+            object.__setattr__(self, "views", tuple(self.views))
+        object.__setattr__(self, "exclude_views", tuple(self.exclude_views))
+
+    def is_enabled_for(self, key: str | None) -> bool:
+        if key is None:
+            return False
+        if self.views is not None and key not in self.views:
+            return False
+        return key not in self.exclude_views
+
+
+class InfiniteScrollPlugin(BasePlugin):
+    """starlette-admin plugin: infinite scrolling for the list view."""
+
+    # Also the templates/static namespace: everything this plugin ships lives
+    # under "plugins/infinite-scroll/".
+    name = "infinite-scroll"
+
+    def __init__(self, **options: Any) -> None:
+        self.config = InfiniteScrollConfig(**options)
+
+    # -- Helpers ---------------------------------------------------------
+
+    def is_active(self, request: Request) -> bool:
+        """Whether the current request renders a list page that should get
+        infinite scrolling."""
+        if getattr(request.state, "action", None) != RequestAction.LIST:
+            return False
+        return self.config.is_enabled_for(request.path_params.get("key"))
+
+    def client_config(self, request: Request) -> dict[str, Any]:
+        """Options handed to the frontend script."""
+        route_name = request.app.state.ROUTE_NAME
+        key = request.path_params["key"]
+        return {
+            "rootMargin": self.config.root_margin,
+            "hidePagination": self.config.hide_pagination,
+            "maxAutoPages": self.config.max_auto_pages,
+            "actionUrl": str(request.url_for(f"{route_name}:action", key=key)),
+            "rowActionUrl": str(request.url_for(f"{route_name}:row-action", key=key)),
+            "i18n": {
+                "loading": _("Loading..."),
+                "loadMore": _("Load more"),
+                "retry": _("Retry"),
+                "error": _("Could not load more rows."),
+                "end": _("All rows loaded"),
+            },
+        }
+
+    # -- Declarative hooks -----------------------------------------------
+
+    def css_links(self, request: Request) -> list[str]:
+        if not self.is_active(request):
+            return []
+        return [
+            static_url(
+                request, "plugins/infinite-scroll/css/infinite-scroll.css", v=_VERSION
+            )
+        ]
+
+    def js_links(self, request: Request) -> list[str]:
+        if not self.is_active(request):
+            return []
+        # Plugin scripts are plain <script src> tags, so the options travel in
+        # the script URL and are read back through `document.currentScript`.
+        url = static_url(
+            request, "plugins/infinite-scroll/js/infinite-scroll.js", v=_VERSION
+        )
+        cfg = json.dumps(self.client_config(request), separators=(",", ":"))
+        return [str(URL(url).include_query_params(config=cfg))]
+
+    def template_globals(self) -> dict[str, Any]:
+        # Auto-prefixed by registration: templates read "infinite_scroll_config".
+        return {"config": asdict(self.config)}

starlette_admin_infinite_scroll-0.1.0/src/starlette_admin_infinite_scroll/static/plugins/infinite-scroll/css/infinite-scroll.css

@@ -0,0 +1,27 @@
+/* starlette-admin-infinite-scroll */
+
+.sa-infinite-scroll-status {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.25rem;
+  min-height: 3rem;
+  padding: 0.75rem 1rem;
+}
+
+.sa-infinite-scroll-status:empty {
+  min-height: 0;
+  padding: 0;
+}
+
+.sa-infinite-scroll-sentinel {
+  height: 1px;
+  width: 100%;
+}
+
+/* Page links and "go to page" are meaningless once pages are appended; the
+   "Showing x to y of z" summary and the page size selector stay. */
+.sa-infinite-scroll--hide-pagination .card-footer .pagination,
+.sa-infinite-scroll--hide-pagination .card-footer form {
+  display: none !important;
+}

starlette_admin_infinite_scroll-0.1.0/src/starlette_admin_infinite_scroll/static/plugins/infinite-scroll/js/infinite-scroll.js

@@ -0,0 +1,454 @@
+/**
+ * starlette-admin-infinite-scroll
+ *
+ * Turns the paginated list page into an infinitely scrolling one. When the
+ * bottom of the list table approaches the viewport, the next page of the
+ * regular list route is fetched (keeping every current query param: search,
+ * sort, filters, visible columns, page size), its `<tr data-sa-pk>` rows are
+ * extracted and appended to the current table.
+ *
+ * Rows come from core's own `_list_row.html`, and core list handlers
+ * (row selection, row click navigation, inline edit, confirmation actions)
+ * are delegated to the document, so appended rows behave like server
+ * rendered ones. Per-element bindings (tooltips, JSON viewers, search
+ * highlight, no-confirmation row actions) are re-applied to new rows here.
+ *
+ * Options are passed by the Python plugin as a JSON `config` query param on
+ * this script's URL.
+ */
+(function () {
+  "use strict";
+
+  var DEFAULTS = {
+    rootMargin: "400px",
+    hidePagination: true,
+    maxAutoPages: 0,
+    actionUrl: "",
+    rowActionUrl: "",
+    i18n: {
+      loading: "Loading...",
+      loadMore: "Load more",
+      retry: "Retry",
+      error: "Could not load more rows.",
+      end: "All rows loaded",
+    },
+  };
+
+  // `document.currentScript` is only set while this file executes.
+  function readConfig() {
+    var cfg = {};
+    try {
+      var script = document.currentScript;
+      if (script && script.src) {
+        var raw = new URL(script.src, window.location.href).searchParams.get("config");
+        if (raw) cfg = JSON.parse(raw);
+      }
+    } catch (e) {
+      /* fall back to defaults */
+    }
+    var merged = Object.assign({}, DEFAULTS, cfg);
+    merged.i18n = Object.assign({}, DEFAULTS.i18n, cfg.i18n || {});
+    return merged;
+  }
+
+  var config = readConfig();
+
+  function getClass(name, fallback) {
+    var sa = window.StarletteAdmin;
+    return sa && typeof sa.getClass === "function" ? sa.getClass(name, fallback) : fallback;
+  }
+
+  function pageFromHref(href) {
+    if (!href) return null;
+    try {
+      var value = new URL(href, window.location.href).searchParams.get("page");
+      var n = parseInt(value || "1", 10);
+      return isNaN(n) ? null : n;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /** Replace the n-th (0-based) integer found in `text` with `value`. */
+  function replaceNthNumber(text, n, value) {
+    var i = -1;
+    return text.replace(/\d+/g, function (m) {
+      i += 1;
+      return i === n ? String(value) : m;
+    });
+  }
+
+  function nthNumber(text, n) {
+    var matches = (text || "").match(/\d+/g);
+    return matches && matches.length > n ? parseInt(matches[n], 10) : null;
+  }
+
+  function cssEscape(value) {
+    return window.CSS && CSS.escape ? CSS.escape(value) : String(value).replace(/"/g, '\\"');
+  }
+
+  function InfiniteScroll(tbody) {
+    this.tbody = tbody;
+    this.table = tbody.closest("table");
+    this.card = this.table.closest(".card") || this.table.parentElement;
+    this.footer = this.card.querySelector(".card-footer");
+    this.summary = this.footer ? this.footer.querySelector("p") : null;
+    this.pagination = this.footer ? this.footer.querySelector(".pagination") : null;
+
+    var params = new URLSearchParams(window.location.search);
+    this.currentPage = parseInt(params.get("page") || "1", 10) || 1;
+    this.totalPages = this.detectTotalPages();
+    this.autoLoaded = 0;
+    this.loading = false;
+    this.done = false;
+    this.failed = false;
+  }
+
+  /**
+   * Total page count, read from the pagination's "Last" link (the last
+   * `.page-link`). Returns `null` when a theme renders no pagination, in
+   * which case pages are loaded until one yields no new rows.
+   */
+  InfiniteScroll.prototype.detectTotalPages = function () {
+    if (!this.pagination) return null;
+    var links = this.pagination.querySelectorAll("a.page-link[href]");
+    if (!links.length) return null;
+    return pageFromHref(links[links.length - 1].getAttribute("href"));
+  };
+
+  InfiniteScroll.prototype.hasMore = function () {
+    if (this.done) return false;
+    return this.totalPages === null || this.currentPage < this.totalPages;
+  };
+
+  InfiniteScroll.prototype.mount = function () {
+    if (!this.hasMore()) return;
+
+    this.card.classList.add("sa-infinite-scroll");
+    if (config.hidePagination) this.card.classList.add("sa-infinite-scroll--hide-pagination");
+
+    this.status = document.createElement("div");
+    this.status.className = "sa-infinite-scroll-status";
+    this.status.setAttribute("data-sa-hook", "infinite-scroll-status");
+    this.status.setAttribute("aria-live", "polite");
+
+    this.sentinel = document.createElement("div");
+    this.sentinel.className = "sa-infinite-scroll-sentinel";
+    this.sentinel.setAttribute("aria-hidden", "true");
+
+    var anchor = this.table.closest(".table-responsive") || this.table;
+    anchor.insertAdjacentElement("afterend", this.status);
+    this.status.insertAdjacentElement("afterend", this.sentinel);
+
+    this.initActionManager();
+    this.observe();
+  };
+
+  InfiniteScroll.prototype.observe = function () {
+    var self = this;
+    if (!("IntersectionObserver" in window)) {
+      // Very old browser: degrade to a manual "Load more" button.
+      this.renderButton(config.i18n.loadMore);
+      return;
+    }
+    this.observer = new IntersectionObserver(
+      function (entries) {
+        entries.forEach(function (entry) {
+          if (entry.isIntersecting) self.maybeAutoLoad();
+        });
+      },
+      { rootMargin: "0px 0px " + config.rootMargin + " 0px" }
+    );
+    this.observer.observe(this.sentinel);
+  };
+
+  InfiniteScroll.prototype.autoLimitReached = function () {
+    return config.maxAutoPages > 0 && this.autoLoaded >= config.maxAutoPages;
+  };
+
+  InfiniteScroll.prototype.maybeAutoLoad = function () {
+    if (this.loading || this.failed || !this.hasMore()) return;
+    if (this.autoLimitReached()) {
+      this.renderButton(config.i18n.loadMore);
+      return;
+    }
+    this.autoLoaded += 1;
+    this.loadNext();
+  };
+
+  /**
+   * After a page is appended the sentinel may still be in view (short pages,
+   * tall screens). The observer does not fire again for an element that
+   * stays visible, so re-check explicitly.
+   */
+  InfiniteScroll.prototype.recheck = function () {
+    if (!this.sentinel || !this.hasMore()) return;
+    var rect = this.sentinel.getBoundingClientRect();
+    var margin = parseInt(config.rootMargin, 10) || 0;
+    if (rect.top <= window.innerHeight + margin) this.maybeAutoLoad();
+  };
+
+  InfiniteScroll.prototype.nextUrl = function () {
+    var url = new URL(window.location.href);
+    url.searchParams.set("page", String(this.currentPage + 1));
+    url.hash = "";
+    return url.toString();
+  };
+
+  InfiniteScroll.prototype.loadNext = function () {
+    var self = this;
+    if (this.loading || !this.hasMore()) return Promise.resolve();
+    this.loading = true;
+    this.failed = false;
+    this.renderLoading();
+
+    return fetch(this.nextUrl(), {
+      credentials: "same-origin",
+      headers: { Accept: "text/html", "X-Requested-With": "XMLHttpRequest" },
+    })
+      .then(function (response) {
+        if (!response.ok) throw new Error("HTTP " + response.status);
+        return response.text();
+      })
+      .then(function (html) {
+        var doc = new DOMParser().parseFromString(html, "text/html");
+        var added = self.appendRows(doc);
+        self.currentPage += 1;
+        self.syncFromDocument(doc);
+        if (added === 0) self.done = true;
+        self.loading = false;
+        self.afterLoad();
+      })
+      .catch(function () {
+        self.loading = false;
+        self.failed = true;
+        self.renderError();
+      });
+  };
+
+  /** Append the rows of a fetched page, skipping pks already displayed. */
+  InfiniteScroll.prototype.appendRows = function (doc) {
+    var self = this;
+    var rows = Array.prototype.slice.call(doc.querySelectorAll("tbody tr[data-sa-pk]"));
+    var selectAll = document.querySelector('[data-sa-hook="select-all"]');
+    var selectAllChecked = !!(selectAll && selectAll.checked && !selectAll.indeterminate);
+    var fragment = document.createDocumentFragment();
+    var added = [];
+
+    rows.forEach(function (row) {
+      var pk = row.getAttribute("data-sa-pk");
+      if (self.tbody.querySelector('tr[data-sa-pk="' + cssEscape(pk) + '"]')) return;
+      var imported = document.importNode(row, true);
+      if (selectAllChecked) {
+        // Keep "all rows selected" (and "select all matching") consistent.
+        var box = imported.querySelector('[data-sa-hook="row-checkbox"]');
+        if (box) {
+          box.checked = true;
+          imported.setAttribute("data-sa-selected", "");
+        }
+      }
+      fragment.appendChild(imported);
+      added.push(imported);
+    });
+
+    if (!added.length) return 0;
+    this.tbody.appendChild(fragment);
+    added.forEach(function (row) {
+      self.bindRow(row);
+    });
+    this.refreshSelection();
+    this.updateSummary();
+    this.card.dispatchEvent(
+      new CustomEvent("sa:infinite-scroll:rows-appended", {
+        bubbles: true,
+        detail: { rows: added, page: this.currentPage + 1 },
+      })
+    );
+    return added.length;
+  };
+
+  /** Re-apply the per-element bindings core applies once on page load. */
+  InfiniteScroll.prototype.bindRow = function (row) {
+    if (typeof window.initTooltips === "function") window.initTooltips(row);
+    if (typeof window.initJsonViewers === "function" && window.jQuery && jQuery.fn.jsonViewer) {
+      window.initJsonViewers(jQuery(row).find("div.field-json[data-json]"));
+    }
+    if (this.actionManager) this.actionManager.initNoConfirmationActions(row);
+    this.highlight(row);
+  };
+
+  InfiniteScroll.prototype.highlight = function (row) {
+    if (typeof window.walkTextNodes !== "function") return;
+    var q = document.querySelector('input[name="q"]');
+    var term = q && q.value;
+    if (!term || !term.trim()) return;
+    var escaped = term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    var regex = new RegExp("(" + escaped + ")", "gi");
+    row.querySelectorAll("td").forEach(function (td) {
+      window.walkTextNodes(td, regex);
+    });
+  };
+
+  /**
+   * Core's `initRowSelection` keeps its state in a closure; its delegated
+   * `change` handler on row checkboxes recomputes everything (counter,
+   * select-all state, banner) from the live DOM, so poke it.
+   */
+  InfiniteScroll.prototype.refreshSelection = function () {
+    var box = this.tbody.querySelector('[data-sa-hook="row-checkbox"]');
+    if (box && window.jQuery) jQuery(box).trigger("change");
+    // "All N rows on this page are selected": now N is every loaded row.
+    var bannerPage = document.querySelector('[data-sa-hook="select-all-banner-page"]');
+    if (bannerPage && bannerPage.firstChild && bannerPage.firstChild.nodeType === Node.TEXT_NODE) {
+      var count = this.tbody.querySelectorAll("tr[data-sa-pk]").length;
+      bannerPage.firstChild.textContent = replaceNthNumber(bannerPage.firstChild.textContent, 0, count);
+    }
+  };
+
+  /** Rewrite "Showing x to y of z" so `y` covers every loaded row. */
+  InfiniteScroll.prototype.updateSummary = function () {
+    if (!this.summary) return;
+    var text = this.summary.textContent;
+    var start = nthNumber(text, 0);
+    var total = nthNumber(text, 2);
+    if (start === null) return;
+    var loaded = this.tbody.querySelectorAll("tr[data-sa-pk]").length;
+    var end = start + loaded - 1;
+    if (total !== null) end = Math.min(end, total);
+    this.summary.textContent = replaceNthNumber(text, 1, end);
+  };
+
+  /** Pick up a changed page count (rows created/deleted meanwhile). */
+  InfiniteScroll.prototype.syncFromDocument = function (doc) {
+    var links = doc.querySelectorAll(".card-footer .pagination a.page-link[href]");
+    if (links.length) {
+      var total = pageFromHref(links[links.length - 1].getAttribute("href"));
+      if (total !== null) this.totalPages = total;
+    }
+  };
+
+  InfiniteScroll.prototype.afterLoad = function () {
+    var self = this;
+    if (!this.hasMore()) {
+      this.finish();
+      return;
+    }
+    if (this.autoLimitReached()) {
+      this.renderButton(config.i18n.loadMore);
+      return;
+    }
+    this.clearStatus();
+    window.requestAnimationFrame(function () {
+      self.recheck();
+    });
+  };
+
+  InfiniteScroll.prototype.finish = function () {
+    this.done = true;
+    if (this.observer) this.observer.disconnect();
+    if (this.sentinel) this.sentinel.remove();
+    this.sentinel = null;
+    this.status.replaceChildren();
+    if (this.currentPage > 1) {
+      var end = document.createElement("span");
+      end.className = "text-muted small";
+      end.textContent = config.i18n.end;
+      this.status.appendChild(end);
+    }
+  };
+
+  InfiniteScroll.prototype.clearStatus = function () {
+    this.status.replaceChildren();
+  };
+
+  InfiniteScroll.prototype.renderLoading = function () {
+    var spinner;
+    var sa = window.StarletteAdmin;
+    try {
+      spinner = sa && typeof sa.template === "function" ? sa.template("spinner") : null;
+    } catch (e) {
+      spinner = null;
+    }
+    if (!spinner) {
+      spinner = document.createElement("span");
+      spinner.className = "spinner-border spinner-border-sm";
+      spinner.setAttribute("role", "status");
+    }
+    var label = document.createElement("span");
+    label.className = "ms-2 text-muted";
+    label.textContent = config.i18n.loading;
+    this.status.replaceChildren(spinner, label);
+  };
+
+  InfiniteScroll.prototype.renderButton = function (text) {
+    var self = this;
+    var button = document.createElement("button");
+    button.type = "button";
+    button.className = getClass("infinite_scroll.load_more_button", "btn btn-outline-secondary btn-sm");
+    button.setAttribute("data-sa-action", "infinite-scroll-load-more");
+    button.textContent = text;
+    button.addEventListener("click", function () {
+      self.loadNext();
+    });
+    this.status.replaceChildren(button);
+  };
+
+  InfiniteScroll.prototype.renderError = function () {
+    var message = document.createElement("span");
+    message.className = "text-danger me-2";
+    message.textContent = config.i18n.error;
+    this.status.replaceChildren(message);
+    var self = this;
+    var button = document.createElement("button");
+    button.type = "button";
+    button.className = getClass("infinite_scroll.retry_button", "btn btn-outline-danger btn-sm");
+    button.setAttribute("data-sa-action", "infinite-scroll-retry");
+    button.textContent = config.i18n.retry;
+    button.addEventListener("click", function () {
+      self.loadNext();
+    });
+    this.status.appendChild(button);
+  };
+
+  /**
+   * Rows appended here miss the per-element click bindings core's
+   * ActionManager puts on no-confirmation row actions. A dedicated instance
+   * handles them (row actions only need the row's pk); confirmation actions
+   * go through the shared modal and already work.
+   */
+  InfiniteScroll.prototype.initActionManager = function () {
+    if (typeof ActionManager === "undefined" || !config.rowActionUrl) return;
+    this.actionManager = new ActionManager(
+      config.actionUrl,
+      config.rowActionUrl,
+      function (query, element) {
+        query.append("pk", element.closest("tr").data("sa-pk"));
+      },
+      function (actionName, element, msg) {
+        if (typeof successAlert === "function") successAlert(msg);
+        window.location.reload();
+      },
+      function (actionName, element, error) {
+        if (typeof dangerAlert === "function") dangerAlert(error);
+      }
+    );
+  };
+
+  function init() {
+    var firstRow = document.querySelector("table tbody tr[data-sa-pk]");
+    if (!firstRow) return; // empty list: nothing to extend
+    var tbody = firstRow.closest("tbody");
+    if (tbody.hasAttribute("data-sa-infinite-scroll")) return; // idempotent
+    tbody.setAttribute("data-sa-infinite-scroll", "");
+    var instance = new InfiniteScroll(tbody);
+    instance.mount();
+    window.StarletteAdmin = window.StarletteAdmin || {};
+    window.StarletteAdmin.infiniteScroll = instance;
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();

starlette_admin_infinite_scroll-0.1.0/tests/conftest.py

@@ -0,0 +1,94 @@
+import pytest
+from sqlalchemy import Integer, create_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, Session, mapped_column
+from sqlalchemy.pool import StaticPool
+from starlette.applications import Starlette
+from starlette.testclient import TestClient
+from starlette_admin.contrib.sqla import Admin, ModelView
+
+from starlette_admin_infinite_scroll import InfiniteScrollPlugin
+
+
+class Base(DeclarativeBase):
+    """Base class for the in-memory demo model used across tests."""
+
+
+class Product(Base):
+    __tablename__ = "products"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    name: Mapped[str]
+
+
+class ProductView(ModelView):
+    fields = [
+        "id",
+        "name",
+    ]
+
+
+class CsrfTestClient(TestClient):
+    """Drop-in `TestClient` replacement that automatically handles CSRF.
+
+    `BaseAdmin` always attaches CSRF middleware, so a plain `TestClient` POST is
+    rejected with a 403. This client fetches the admin index on construction to
+    obtain the signed `starlette_admin_csrftoken` cookie, then sends it as
+    `X-CSRFToken` on every mutating request.
+    """
+
+    def __init__(self, app, **kwargs):
+        super().__init__(app, **kwargs)
+        self.get("/admin/")
+        self._csrf_token = self.cookies.get("starlette_admin_csrftoken", "")
+
+    def _with_csrf_header(self, kwargs: dict) -> dict:
+        headers = dict(kwargs.pop("headers", None) or {})
+        headers.setdefault("X-CSRFToken", self._csrf_token)
+        kwargs["headers"] = headers
+        return kwargs
+
+    def post(self, url, **kwargs):
+        return super().post(url, **self._with_csrf_header(kwargs))
+
+    def put(self, url, **kwargs):
+        return super().put(url, **self._with_csrf_header(kwargs))
+
+    def delete(self, url, **kwargs):
+        return super().delete(url, **self._with_csrf_header(kwargs))
+
+
+@pytest.fixture
+def plugin():
+    return InfiniteScrollPlugin()
+
+
+@pytest.fixture
+def engine():
+    engine = create_engine(
+        "sqlite:///:memory:",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+    Base.metadata.create_all(engine)
+    return engine
+
+
+@pytest.fixture
+def seed(engine):
+    with Session(engine) as session:
+        session.add_all(Product(id=i, name=f"Product {i}") for i in range(1, 46))
+        session.commit()
+
+
+@pytest.fixture
+def admin(plugin, engine):
+    admin = Admin(engine, secret_key="test", plugins=[plugin])
+    admin.add_view(ProductView(Product))
+    return admin
+
+
+@pytest.fixture
+def client(admin):
+    app = Starlette()
+    admin.mount_to(app)
+    return CsrfTestClient(app, base_url="http://testserver")

starlette_admin_infinite_scroll-0.1.0/tests/test_plugin.py

@@ -0,0 +1,98 @@
+import json
+import re
+from urllib.parse import parse_qs, urlparse
+
+import pytest
+
+from starlette_admin_infinite_scroll import InfiniteScrollConfig, InfiniteScrollPlugin
+
+SCRIPT_RE = re.compile(
+    r'<script[^>]+src="([^"]*plugins/infinite-scroll/js/infinite-scroll\.js[^"]*)"'
+)
+CSS_PATH = "plugins/infinite-scroll/css/infinite-scroll.css"
+
+
+def _script_config(html: str) -> dict:
+    match = SCRIPT_RE.search(html)
+    assert match, "infinite-scroll script not injected"
+    src = match.group(1).replace("&amp;", "&")
+    return json.loads(parse_qs(urlparse(src).query)["config"][0])
+
+
+def test_plugin_registers_under_its_name(admin, plugin):
+    assert admin.plugins == {"infinite-scroll": plugin}
+
+
+def test_assets_injected_on_list_page(client):
+    response = client.get("/admin/product/list")
+    assert response.status_code == 200
+    assert SCRIPT_RE.search(response.text)
+    assert CSS_PATH in response.text
+
+
+@pytest.mark.parametrize("url", ["/admin/", "/admin/product/create"])
+def test_assets_not_injected_outside_list_page(client, url):
+    response = client.get(url)
+    assert response.status_code == 200
+    assert not SCRIPT_RE.search(response.text)
+    assert CSS_PATH not in response.text
+
+
+def test_script_config_defaults(client):
+    cfg = _script_config(client.get("/admin/product/list").text)
+    assert cfg["rootMargin"] == "400px"
+    assert cfg["hidePagination"] is True
+    assert cfg["maxAutoPages"] == 0
+    assert cfg["rowActionUrl"].endswith("/product/row-action")
+    assert cfg["actionUrl"].endswith("/product/action")
+    assert set(cfg["i18n"]) == {"loading", "loadMore", "retry", "error", "end"}
+
+
+@pytest.mark.parametrize(
+    "plugin",
+    [
+        InfiniteScrollPlugin(
+            root_margin="1000px", hide_pagination=False, max_auto_pages=3
+        )
+    ],
+)
+def test_script_config_options(client):
+    cfg = _script_config(client.get("/admin/product/list").text)
+    assert cfg["rootMargin"] == "1000px"
+    assert cfg["hidePagination"] is False
+    assert cfg["maxAutoPages"] == 3
+
+
+@pytest.mark.parametrize("plugin", [InfiniteScrollPlugin(views=["other"])])
+def test_views_allowlist(client):
+    assert not SCRIPT_RE.search(client.get("/admin/product/list").text)
+
+
+@pytest.mark.parametrize("plugin", [InfiniteScrollPlugin(exclude_views=["product"])])
+def test_exclude_views(client):
+    assert not SCRIPT_RE.search(client.get("/admin/product/list").text)
+
+
+def test_static_assets_served(client):
+    js = client.get("/admin/static/plugins/infinite-scroll/js/infinite-scroll.js")
+    css = client.get(f"/admin/static/{CSS_PATH}")
+    assert js.status_code == 200
+    assert "IntersectionObserver" in js.text
+    assert css.status_code == 200
+
+
+def test_next_page_contains_rows(client, seed):
+    """The script relies on the plain list route rendering `tr[data-sa-pk]`."""
+    html = client.get("/admin/product/list?page=2&page_size=10").text
+    pks = re.findall(r'<tr data-sa-pk="(\d+)"', html)
+    assert pks == [str(i) for i in range(11, 21)]
+
+
+def test_config_validation():
+    with pytest.raises(ValueError):
+        InfiniteScrollConfig(max_auto_pages=-1)
+    cfg = InfiniteScrollConfig(views=["a", "b"], exclude_views=["b"])
+    assert cfg.is_enabled_for("a")
+    assert not cfg.is_enabled_for("b")
+    assert not cfg.is_enabled_for("c")
+    assert not cfg.is_enabled_for(None)