datasette-sticky-table-headers 0.1.0__tar.gz

datasette_sticky_table_headers-0.1.0/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2026 Julius Welby
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

datasette_sticky_table_headers-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+include docs/screenshot.png

datasette_sticky_table_headers-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: datasette-sticky-table-headers
+Version: 0.1.0
+Summary: Datasette plugin that keeps table headers visible while scrolling
+Author: Julius Welby
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/jwelby/datasette-sticky-table-headers
+Project-URL: Issues, https://github.com/jwelby/datasette-sticky-table-headers/issues
+Project-URL: Source, https://github.com/jwelby/datasette-sticky-table-headers
+Keywords: datasette,datasette-plugin,sticky-headers,fixed-headers,frozen-headers,freeze-top-row,tables
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Datasette
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: datasette
+Dynamic: license-file
+
+# datasette-sticky-table-headers
+
+Keep Datasette table headers visible while scrolling.
+
+This plugin is especially useful when exploring wide or unfamiliar datasets:
+column names stay in view while you scroll down table listings, database table
+previews, and SQL query results.
+
+If you know this feature from spreadsheets, it is similar to "freeze top row"
+or "freeze header row": column names remain visible while you scroll through
+long or wide tables.
+
+## Installation
+
+Install the plugin in the same environment as Datasette:
+
+```bash
+datasette install datasette-sticky-table-headers
+```
+
+For local development from this checkout:
+
+```bash
+pip install -e . --no-build-isolation
+```
+
+## Usage
+
+Run Datasette as normal. The plugin is enabled automatically:
+
+```bash
+datasette data.db
+```
+
+It injects a small script on Datasette table, database, and SQL query pages.
+That script adds CSS targeting `thead` header cells in Datasette result tables,
+so the header row sticks to the top of the browser viewport while the page
+scrolls.
+
+```css
+.rows-and-columns thead th {
+  position: sticky;
+  top: 0;
+}
+```
+
+The plugin also makes Datasette's table wrappers use normal page scrolling
+rather than a separate vertical scroll box, which lets sticky headers pin to the
+browser viewport.
+
+## Screenshots
+
+![Datasette table page with sticky headers visible while scrolling](docs/screenshot.png)
+
+The screenshot shows a Datasette table page scrolled down with the column
+headers still visible at the top of the page.
+
+## Compatibility and limitations
+
+Tested with Datasette 0.65.2. The plugin uses Datasette's `extra_body_script`
+hook and standard Datasette table markup, so it should also work with nearby
+Datasette versions that render result tables with `thead` elements and the
+`rows-and-columns` class.
+
+The CSS intentionally targets only `thead` cells. It does not use a
+`tr:first-child` fallback, because that can accidentally make the first data row
+sticky on result tables without a header section.
+
+The header background is white. Datasette themes or custom CSS with non-white
+table backgrounds may need a small override.

datasette_sticky_table_headers-0.1.0/README.md

@@ -0,0 +1,70 @@
+# datasette-sticky-table-headers
+
+Keep Datasette table headers visible while scrolling.
+
+This plugin is especially useful when exploring wide or unfamiliar datasets:
+column names stay in view while you scroll down table listings, database table
+previews, and SQL query results.
+
+If you know this feature from spreadsheets, it is similar to "freeze top row"
+or "freeze header row": column names remain visible while you scroll through
+long or wide tables.
+
+## Installation
+
+Install the plugin in the same environment as Datasette:
+
+```bash
+datasette install datasette-sticky-table-headers
+```
+
+For local development from this checkout:
+
+```bash
+pip install -e . --no-build-isolation
+```
+
+## Usage
+
+Run Datasette as normal. The plugin is enabled automatically:
+
+```bash
+datasette data.db
+```
+
+It injects a small script on Datasette table, database, and SQL query pages.
+That script adds CSS targeting `thead` header cells in Datasette result tables,
+so the header row sticks to the top of the browser viewport while the page
+scrolls.
+
+```css
+.rows-and-columns thead th {
+  position: sticky;
+  top: 0;
+}
+```
+
+The plugin also makes Datasette's table wrappers use normal page scrolling
+rather than a separate vertical scroll box, which lets sticky headers pin to the
+browser viewport.
+
+## Screenshots
+
+![Datasette table page with sticky headers visible while scrolling](docs/screenshot.png)
+
+The screenshot shows a Datasette table page scrolled down with the column
+headers still visible at the top of the page.
+
+## Compatibility and limitations
+
+Tested with Datasette 0.65.2. The plugin uses Datasette's `extra_body_script`
+hook and standard Datasette table markup, so it should also work with nearby
+Datasette versions that render result tables with `thead` elements and the
+`rows-and-columns` class.
+
+The CSS intentionally targets only `thead` cells. It does not use a
+`tr:first-child` fallback, because that can accidentally make the first data row
+sticky on result tables without a header section.
+
+The header background is white. Datasette themes or custom CSS with non-white
+table backgrounds may need a small override.

datasette_sticky_table_headers-0.1.0/datasette_sticky_table_headers.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: datasette-sticky-table-headers
+Version: 0.1.0
+Summary: Datasette plugin that keeps table headers visible while scrolling
+Author: Julius Welby
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/jwelby/datasette-sticky-table-headers
+Project-URL: Issues, https://github.com/jwelby/datasette-sticky-table-headers/issues
+Project-URL: Source, https://github.com/jwelby/datasette-sticky-table-headers
+Keywords: datasette,datasette-plugin,sticky-headers,fixed-headers,frozen-headers,freeze-top-row,tables
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Datasette
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: datasette
+Dynamic: license-file
+
+# datasette-sticky-table-headers
+
+Keep Datasette table headers visible while scrolling.
+
+This plugin is especially useful when exploring wide or unfamiliar datasets:
+column names stay in view while you scroll down table listings, database table
+previews, and SQL query results.
+
+If you know this feature from spreadsheets, it is similar to "freeze top row"
+or "freeze header row": column names remain visible while you scroll through
+long or wide tables.
+
+## Installation
+
+Install the plugin in the same environment as Datasette:
+
+```bash
+datasette install datasette-sticky-table-headers
+```
+
+For local development from this checkout:
+
+```bash
+pip install -e . --no-build-isolation
+```
+
+## Usage
+
+Run Datasette as normal. The plugin is enabled automatically:
+
+```bash
+datasette data.db
+```
+
+It injects a small script on Datasette table, database, and SQL query pages.
+That script adds CSS targeting `thead` header cells in Datasette result tables,
+so the header row sticks to the top of the browser viewport while the page
+scrolls.
+
+```css
+.rows-and-columns thead th {
+  position: sticky;
+  top: 0;
+}
+```
+
+The plugin also makes Datasette's table wrappers use normal page scrolling
+rather than a separate vertical scroll box, which lets sticky headers pin to the
+browser viewport.
+
+## Screenshots
+
+![Datasette table page with sticky headers visible while scrolling](docs/screenshot.png)
+
+The screenshot shows a Datasette table page scrolled down with the column
+headers still visible at the top of the page.
+
+## Compatibility and limitations
+
+Tested with Datasette 0.65.2. The plugin uses Datasette's `extra_body_script`
+hook and standard Datasette table markup, so it should also work with nearby
+Datasette versions that render result tables with `thead` elements and the
+`rows-and-columns` class.
+
+The CSS intentionally targets only `thead` cells. It does not use a
+`tr:first-child` fallback, because that can accidentally make the first data row
+sticky on result tables without a header section.
+
+The header background is white. Datasette themes or custom CSS with non-white
+table backgrounds may need a small override.

datasette_sticky_table_headers-0.1.0/datasette_sticky_table_headers.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+datasette_sticky_table_headers.py
+pyproject.toml
+datasette_sticky_table_headers.egg-info/PKG-INFO
+datasette_sticky_table_headers.egg-info/SOURCES.txt
+datasette_sticky_table_headers.egg-info/dependency_links.txt
+datasette_sticky_table_headers.egg-info/entry_points.txt
+datasette_sticky_table_headers.egg-info/requires.txt
+datasette_sticky_table_headers.egg-info/top_level.txt
+docs/screenshot.png
+tests/test_datasette_sticky_table_headers.py

datasette_sticky_table_headers-0.1.0/datasette_sticky_table_headers.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

datasette_sticky_table_headers-0.1.0/datasette_sticky_table_headers.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[datasette]
+sticky_table_headers = datasette_sticky_table_headers

datasette_sticky_table_headers-0.1.0/datasette_sticky_table_headers.egg-info/requires.txt

@@ -0,0 +1 @@
+datasette

datasette_sticky_table_headers-0.1.0/datasette_sticky_table_headers.egg-info/top_level.txt

@@ -0,0 +1 @@
+datasette_sticky_table_headers

datasette_sticky_table_headers-0.1.0/datasette_sticky_table_headers.py

@@ -0,0 +1,37 @@
+from datasette import hookimpl
+
+
+SCRIPT = """
+(() => {
+  if (document.getElementById("datasette-sticky-table-headers-style")) {
+    return;
+  }
+  const style = document.createElement("style");
+  style.id = "datasette-sticky-table-headers-style";
+  style.textContent = `
+    .table-wrapper,
+    .table-wrapper-overflow,
+    .table-wrapper-scroll {
+      overflow: visible;
+    }
+
+    .rows-and-columns thead th,
+    table.rows-and-columns thead th,
+    table.rows-and-columns thead td {
+      position: sticky;
+      top: 0;
+      z-index: 5;
+      background: #fff;
+      box-shadow: 0 1px 0 rgba(0, 0, 0, 0.12);
+    }
+  `;
+  document.head.appendChild(style);
+})();
+"""
+
+
+@hookimpl
+def extra_body_script(view_name):
+    if view_name not in {"table", "query", "database"}:
+        return None
+    return SCRIPT

datasette_sticky_table_headers-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "datasette-sticky-table-headers"
+version = "0.1.0"
+description = "Datasette plugin that keeps table headers visible while scrolling"
+readme = "README.md"
+authors = [{name = "Julius Welby"}]
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+keywords = [
+    "datasette",
+    "datasette-plugin",
+    "sticky-headers",
+    "fixed-headers",
+    "frozen-headers",
+    "freeze-top-row",
+    "tables",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "datasette",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Datasette",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Database :: Front-Ends",
+]
+
+[project.urls]
+Homepage = "https://github.com/jwelby/datasette-sticky-table-headers"
+Issues = "https://github.com/jwelby/datasette-sticky-table-headers/issues"
+Source = "https://github.com/jwelby/datasette-sticky-table-headers"
+
+[project.entry-points.datasette]
+sticky_table_headers = "datasette_sticky_table_headers"
+
+[tool.setuptools]
+py-modules = ["datasette_sticky_table_headers"]

datasette_sticky_table_headers-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

datasette_sticky_table_headers-0.1.0/tests/test_datasette_sticky_table_headers.py

@@ -0,0 +1,87 @@
+import unittest
+import sqlite3
+import tempfile
+from pathlib import Path
+
+from datasette.app import Datasette
+from datasette import plugins
+
+import datasette_sticky_table_headers
+from datasette_sticky_table_headers import SCRIPT, extra_body_script
+
+
+class StickyTableHeadersTests(unittest.TestCase):
+    def test_script_contains_sticky_css(self):
+        self.assertIn("position: sticky", SCRIPT)
+        self.assertIn(".rows-and-columns thead th", SCRIPT)
+        self.assertNotIn("tr:first-child", SCRIPT)
+        self.assertIn("datasette-sticky-table-headers-style", SCRIPT)
+
+    def test_enabled_on_table_and_query_pages(self):
+        self.assertEqual(SCRIPT, extra_body_script("table"))
+        self.assertEqual(SCRIPT, extra_body_script("query"))
+        self.assertEqual(SCRIPT, extra_body_script("database"))
+
+    def test_disabled_elsewhere(self):
+        self.assertIsNone(extra_body_script("index"))
+
+
+class DatasetteRenderTests(unittest.IsolatedAsyncioTestCase):
+    plugin_name = "datasette-sticky-table-headers-test"
+
+    async def asyncSetUp(self):
+        self.registered_plugin = not plugins.pm.is_registered(
+            datasette_sticky_table_headers
+        )
+        if self.registered_plugin:
+            plugins.pm.register(
+                datasette_sticky_table_headers,
+                name=self.plugin_name,
+            )
+
+        self.tempdir = tempfile.TemporaryDirectory()
+        self.db_path = Path(self.tempdir.name) / "fixtures.db"
+        connection = sqlite3.connect(self.db_path)
+        connection.execute(
+            "create table demo (id integer primary key, name text, notes text)"
+        )
+        connection.execute(
+            "insert into demo (name, notes) values (?, ?)",
+            ("Alice", "wide table header test"),
+        )
+        connection.commit()
+        connection.close()
+
+        self.ds = Datasette([str(self.db_path)])
+
+    async def asyncTearDown(self):
+        if self.registered_plugin:
+            plugins.pm.unregister(name=self.plugin_name)
+        for database in self.ds.databases.values():
+            database.close()
+        self.tempdir.cleanup()
+
+    async def assert_script_injected(self, path):
+        response = await self.ds.client.get(path)
+        self.assertEqual(200, response.status_code)
+        self.assertIn("datasette-sticky-table-headers-style", response.text)
+        self.assertIn(".rows-and-columns thead th", response.text)
+        self.assertNotIn("tr:first-child", response.text)
+
+    async def test_script_injected_on_table_page(self):
+        await self.assert_script_injected("/fixtures/demo")
+
+    async def test_script_injected_on_database_page(self):
+        await self.assert_script_injected("/fixtures")
+
+    async def test_script_injected_on_sql_query_page(self):
+        await self.assert_script_injected("/fixtures?sql=select+*+from+demo")
+
+    async def test_script_not_injected_on_index_page(self):
+        response = await self.ds.client.get("/")
+        self.assertEqual(200, response.status_code)
+        self.assertNotIn("datasette-sticky-table-headers-style", response.text)
+
+
+if __name__ == "__main__":
+    unittest.main()