starlette-admin-infinite-scroll 0.1.0__py3-none-any.whl

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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+starlette_admin_infinite_scroll/__init__.py,sha256=Rs4Fd6x7oDvrY7XR9QfIPWhDUj9DS7yJ_x8osGPcALA,153
+starlette_admin_infinite_scroll/plugin.py,sha256=YSYrNRlVVuUjhI-nfpQVwdXuFQyr4Wp6C5hw7bdPu8k,5448
+starlette_admin_infinite_scroll/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+starlette_admin_infinite_scroll/static/plugins/infinite-scroll/css/infinite-scroll.css,sha256=vXurC0QcC9_47TibJgw-BD52yZmxaspl64lPxT0aS-g,627
+starlette_admin_infinite_scroll/static/plugins/infinite-scroll/js/infinite-scroll.js,sha256=nPdKkG-QK5IUGjtQgs6EOqVDiPJwkc_po_1gnvpZSPE,16119
+starlette_admin_infinite_scroll-0.1.0.dist-info/METADATA,sha256=2C90aeHTefotiyt0EVeakQwIkihq8Rt9riw_AmM-VM8,4304
+starlette_admin_infinite_scroll-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+starlette_admin_infinite_scroll-0.1.0.dist-info/entry_points.txt,sha256=duvOkKkCKbz7nZzb3y39DbtTPFL71Qmo0edJCATHSLw,97
+starlette_admin_infinite_scroll-0.1.0.dist-info/licenses/LICENSE,sha256=f8elJ_j5O4HmoLpWt4g5CF06f_Lxq7MFLjzyTVqgQYc,1074
+starlette_admin_infinite_scroll-0.1.0.dist-info/RECORD,,

starlette_admin_infinite_scroll-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

starlette_admin_infinite_scroll-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[starlette_admin.plugins]
+infinite-scroll = starlette_admin_infinite_scroll:InfiniteScrollPlugin

starlette_admin_infinite_scroll-0.1.0.dist-info/licenses/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.