spaday-regular-table 0.2.2__tar.gz → 0.3.0__tar.gz

{spaday_regular_table-0.2.2 → spaday_regular_table-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: spaday-regular-table
-Version: 0.2.2
+Version: 0.3.0
 Summary: regular-table for spaday
 Project-URL: Repository, https://github.com/1kbgz/spaday-regular-table
 Project-URL: Homepage, https://github.com/1kbgz/spaday-regular-table
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.11
-Requires-Dist: spaday<1.0,>=0.6.0
+Requires-Dist: spaday<1.0,>=0.11.1
 Provides-Extra: develop
 Requires-Dist: build; extra == 'develop'
 Requires-Dist: bump-my-version; extra == 'develop'
@@ -44,8 +44,8 @@ Description-Content-Type: text/markdown
 
 <a href="https://github.com/1kbgz/spaday-regular-table">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/1kbgz/spaday-regular-table/raw/main/docs/img/logo-dark.png?raw=true">
-    <img alt="spaday-regular-table logo, a table with a data-grid top inside a browser window" src="https://github.com/1kbgz/spaday-regular-table/raw/main/docs/img/logo-light.png?raw=true" width="800">
+    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/1kbgz/spaday-regular-table/raw/main/docs/img/logo-dark.webp?raw=true">
+    <img alt="spaday-regular-table logo, a table with a data-grid top inside a browser window" src="https://github.com/1kbgz/spaday-regular-table/raw/main/docs/img/logo-light.webp?raw=true" width="800">
   </picture>
 </a>
 
@@ -56,6 +56,8 @@ Viewport-virtualized data tables for spaday, powered by `regular-table`.
 [![License](https://img.shields.io/github/license/1kbgz/spaday-regular-table)](https://github.com/1kbgz/spaday-regular-table)
 [![PyPI](https://img.shields.io/pypi/v/spaday-regular-table.svg)](https://pypi.python.org/pypi/spaday-regular-table)
 
+[![Preview of regular-table page](https://raw.githubusercontent.com/1kbgz/spaday-regular-table/main/docs/img/preview.webp)](./spaday_regular_table/example.py)
+
 ## Documentation
 
 - [Build a 100,000-row table](docs/src/tutorial.md) — guided virtual-table example.
@@ -104,6 +106,8 @@ browser methods remain available to integration authors, but applications need n
 
 ## Run the local example
 
+[Run the complete example in your browser](https://1kbgz.github.io/spaday-regular-table/lite/) — Python runs locally through Pyodide; no install or server required.
+
 ```bash
 python -m pip install -e ".[examples]"
 python -m spaday_regular_table.example
@@ -114,3 +118,6 @@ virtualized rows, a server row stream, full-width sizing, rich cells, and server
 insert, remove, and click operations. All interaction is authored in Python; there is no companion
 `example.js`. It passes the local package descriptor directly, so it does not install or resolve the
 integration from GitHub.
+
+> [!NOTE]
+> This library was generated using [copier](https://copier.readthedocs.io/en/stable/) from the [Base Python Project Template repository](https://github.com/python-project-templates/base).

{spaday_regular_table-0.2.2 → spaday_regular_table-0.3.0}/README.md

@@ -1,7 +1,7 @@
 <a href="https://github.com/1kbgz/spaday-regular-table">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/1kbgz/spaday-regular-table/raw/main/docs/img/logo-dark.png?raw=true">
-    <img alt="spaday-regular-table logo, a table with a data-grid top inside a browser window" src="https://github.com/1kbgz/spaday-regular-table/raw/main/docs/img/logo-light.png?raw=true" width="800">
+    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/1kbgz/spaday-regular-table/raw/main/docs/img/logo-dark.webp?raw=true">
+    <img alt="spaday-regular-table logo, a table with a data-grid top inside a browser window" src="https://github.com/1kbgz/spaday-regular-table/raw/main/docs/img/logo-light.webp?raw=true" width="800">
   </picture>
 </a>
 
@@ -12,6 +12,8 @@ Viewport-virtualized data tables for spaday, powered by `regular-table`.
 [![License](https://img.shields.io/github/license/1kbgz/spaday-regular-table)](https://github.com/1kbgz/spaday-regular-table)
 [![PyPI](https://img.shields.io/pypi/v/spaday-regular-table.svg)](https://pypi.python.org/pypi/spaday-regular-table)
 
+[![Preview of regular-table page](https://raw.githubusercontent.com/1kbgz/spaday-regular-table/main/docs/img/preview.webp)](./spaday_regular_table/example.py)
+
 ## Documentation
 
 - [Build a 100,000-row table](docs/src/tutorial.md) — guided virtual-table example.
@@ -60,6 +62,8 @@ browser methods remain available to integration authors, but applications need n
 
 ## Run the local example
 
+[Run the complete example in your browser](https://1kbgz.github.io/spaday-regular-table/lite/) — Python runs locally through Pyodide; no install or server required.
+
 ```bash
 python -m pip install -e ".[examples]"
 python -m spaday_regular_table.example
@@ -70,3 +74,6 @@ virtualized rows, a server row stream, full-width sizing, rich cells, and server
 insert, remove, and click operations. All interaction is authored in Python; there is no companion
 `example.js`. It passes the local package descriptor directly, so it does not install or resolve the
 integration from GitHub.
+
+> [!NOTE]
+> This library was generated using [copier](https://copier.readthedocs.io/en/stable/) from the [Base Python Project Template repository](https://github.com/python-project-templates/base).

{spaday_regular_table-0.2.2 → spaday_regular_table-0.3.0}/js/build.mjs

@@ -42,6 +42,23 @@ async function build() {
 
   await Promise.all(BUNDLES.map(bundle)).catch(() => process.exit(1));
 
+  // the exact version of every library this package serves, read by the Python package as its
+  // ComponentPackage.provides, so spaday can reconcile it with the other packages on a page
+  const { dependencies = {} } = JSON.parse(
+    fs.readFileSync("package.json", "utf8"),
+  );
+  const served = Object.fromEntries(
+    Object.keys(dependencies).map((name) => [
+      name,
+      JSON.parse(fs.readFileSync(`node_modules/${name}/package.json`, "utf8"))
+        .version,
+    ]),
+  );
+  fs.writeFileSync(
+    "dist/versions.json",
+    `${JSON.stringify(served, null, 2)}\n`,
+  );
+
   // Copy servable assets to python extension (exclude esm/)
   fs.mkdirSync("../spaday_regular_table/extension", { recursive: true });
   await cpy("dist/**/*", "../spaday_regular_table/extension", {

spaday_regular_table-0.3.0/js/examples/build_pyodide_example.py

@@ -0,0 +1,48 @@
+"""Assemble the static Pyodide example from locally built and downloaded wheels."""
+
+import json
+import shutil
+import sys
+import zipfile
+from pathlib import Path
+
+
+def copy_wheel(wheel: Path, output: Path) -> str:
+    target = output / "pypi" / wheel.name
+    target.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(wheel, target)
+    return f"pypi/{wheel.name}"
+
+
+def extract_assets(wheel: Path, package: str, output: Path) -> None:
+    prefix = f"{package}/extension/"
+    with zipfile.ZipFile(wheel) as archive:
+        assets = [name for name in archive.namelist() if name.startswith(prefix) and not name.endswith("/")]
+        if not assets:
+            raise RuntimeError(f"{wheel.name} contains no browser assets")
+        for name in assets:
+            target = output / name.removeprefix(prefix)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_bytes(archive.read(name))
+
+
+def one_wheel(directory: Path, distribution: str) -> Path:
+    wheels = list(directory.glob(f"{distribution}-*.whl"))
+    if len(wheels) != 1:
+        raise RuntimeError(f"expected one {distribution} wheel in {directory}, found {len(wheels)}")
+    return wheels[0]
+
+
+def main(output: Path, table_wheel: Path, dependency_dir: Path) -> None:
+    spaday_wheel = one_wheel(dependency_dir, "spaday")
+    wheels = {
+        "table": copy_wheel(table_wheel, output),
+        "spaday": copy_wheel(spaday_wheel, output),
+    }
+    extract_assets(table_wheel, "spaday_regular_table", output / "components" / "regular-table")
+    extract_assets(spaday_wheel, "spaday", output / "runtime" / "spaday")
+    (output / "wheels.json").write_text(json.dumps(wheels, indent=2) + "\n")
+
+
+if __name__ == "__main__":
+    main(*(Path(value) for value in sys.argv[1:]))

spaday_regular_table-0.3.0/js/examples/pyodide-worker.js

@@ -0,0 +1,100 @@
+const PYODIDE_VERSION = "314.0.4";
+let pyodide;
+
+const ready = (async () => {
+  self.postMessage({ type: "status", message: "Loading Pyodide…" });
+  const { loadPyodide } = await import(
+    `https://cdn.jsdelivr.net/pyodide/v${PYODIDE_VERSION}/full/pyodide.mjs`
+  );
+  pyodide = await loadPyodide();
+  await pyodide.loadPackage(["micropip", "anyio"]);
+
+  self.postMessage({ type: "status", message: "Installing example…" });
+  const response = await fetch(new URL("./wheels.json", self.location.href));
+  if (!response.ok)
+    throw new Error(`wheel manifest returned ${response.status}`);
+  const wheels = await response.json();
+  const urls = Object.fromEntries(
+    Object.entries(wheels).map(([name, path]) => [
+      name,
+      new URL(path, self.location.href).href,
+    ]),
+  );
+  pyodide.globals.set("wheels_json", JSON.stringify(urls));
+  return pyodide.runPythonAsync(`
+import asyncio
+import json
+import micropip
+
+wheels = json.loads(wheels_json)
+await micropip.install([wheels["spaday"], "starlette", "uvicorn"])
+await micropip.install(wheels["table"], deps=False)
+
+from spaday_regular_table import example
+
+pending_patches = []
+native_publish = example.publish
+
+def publish(*operations):
+    patch = native_publish(*operations)
+    pending_patches.append(patch)
+    return patch
+
+example.publish = publish
+
+def flush_stream():
+    patches = list(pending_patches)
+    pending_patches.clear()
+    return json.dumps(patches)
+
+class LocalRequest:
+    def __init__(self, action, body):
+        self.path_params = {"action": action}
+        self._body = body
+
+    async def json(self):
+        return self._body
+
+async def call_endpoint(action, body_json):
+    response = await example.table_action(LocalRequest(action, json.loads(body_json)))
+    return json.dumps({
+        "status": response.status_code,
+        "body": json.loads(bytes(response.body).decode()),
+    })
+
+asyncio.create_task(example.stream_rows())
+
+json.dumps({
+    "tree": example.page.to_node(),
+    "style": example.styles,
+    "store": example.initial_store,
+})
+`);
+})();
+
+let queue = Promise.resolve();
+
+async function handle(message) {
+  const snapshot = await ready;
+  if (message.type === "start") {
+    self.postMessage({ type: "snapshot", payload: JSON.parse(snapshot) });
+  } else if (message.type === "flush") {
+    const patches = JSON.parse(pyodide.runPython("flush_stream()"));
+    if (patches.length) self.postMessage({ type: "stream", patches });
+  } else if (message.type === "endpoint") {
+    pyodide.globals.set("action", message.action);
+    pyodide.globals.set("body_json", JSON.stringify(message.body));
+    const result = JSON.parse(
+      await pyodide.runPythonAsync("await call_endpoint(action, body_json)"),
+    );
+    self.postMessage({ type: "endpoint", id: message.id, ...result });
+  }
+}
+
+self.addEventListener("message", (event) => {
+  queue = queue
+    .then(() => handle(event.data))
+    .catch((error) => {
+      self.postMessage({ type: "error", message: String(error) });
+    });
+});

spaday_regular_table-0.3.0/js/examples/pyodide.html

@@ -0,0 +1,151 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>spaday-regular-table in Pyodide</title>
+    <link rel="stylesheet" href="./components/regular-table/css/index.css" />
+    <link rel="stylesheet" href="./components/regular-table/css/material.css" />
+    <link rel="stylesheet" href="./components/regular-table/css/theme.css" />
+    <style>
+      #pyodide-status {
+        position: sticky;
+        z-index: 10000;
+        top: 0;
+        box-sizing: border-box;
+        min-height: 3rem;
+        padding: 0.75rem 1rem;
+        border-bottom: 1px solid #cbd5e1;
+        color: #475569;
+        background: #fffffff2;
+        font:
+          14px/1.4 system-ui,
+          sans-serif;
+        backdrop-filter: blur(12px);
+      }
+      #pyodide-error {
+        margin: 1rem;
+        color: #b91c1c;
+        white-space: pre-wrap;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="pyodide-status">Loading Python in the browser…</div>
+    <div id="example-root"></div>
+    <pre id="pyodide-error" hidden></pre>
+    <script type="module">
+      import { init, mount, Store } from "./runtime/spaday/cdn/index.js";
+      import "./components/regular-table/cdn/index.js";
+
+      const status = document.querySelector("#pyodide-status");
+      const pendingEndpoints = new Map();
+      const streamSources = new Set();
+      let nextEndpointId = 0;
+
+      class LocalEventSource extends EventTarget {
+        static CLOSED = 2;
+        static CONNECTING = 0;
+        static OPEN = 1;
+
+        constructor(url) {
+          super();
+          const path = new URL(url, location.href).pathname;
+          if (path !== "/api/table/stream")
+            throw new Error(`unsupported local event stream: ${path}`);
+          this.readyState = LocalEventSource.CONNECTING;
+          this.url = new URL(url, location.href).href;
+          streamSources.add(this);
+          queueMicrotask(() => {
+            this.readyState = LocalEventSource.OPEN;
+            this.dispatchEvent(new Event("open"));
+          });
+        }
+
+        close() {
+          this.readyState = LocalEventSource.CLOSED;
+          streamSources.delete(this);
+        }
+      }
+
+      globalThis.EventSource = LocalEventSource;
+
+      function fail(error) {
+        status.textContent = "Unable to start";
+        const output = document.querySelector("#pyodide-error");
+        output.hidden = false;
+        output.textContent = String(error);
+      }
+
+      try {
+        await init({ module_or_path: "./runtime/spaday/pkg/spaday_bg.wasm" });
+
+        const worker = new Worker("./pyodide-worker.js", { type: "module" });
+        const nativeFetch = globalThis.fetch.bind(globalThis);
+        globalThis.fetch = async (input, options = {}) => {
+          const url = new URL(
+            input instanceof Request ? input.url : input,
+            location.href,
+          );
+          const match = url.pathname.match(
+            /^\/api\/table\/(click|update|insert|remove)$/,
+          );
+          if (!match) return nativeFetch(input, options);
+
+          const id = ++nextEndpointId;
+          const response = new Promise((resolve) => {
+            pendingEndpoints.set(id, resolve);
+          });
+          worker.postMessage({
+            type: "endpoint",
+            id,
+            action: match[1],
+            body: options.body ? JSON.parse(String(options.body)) : null,
+          });
+          return response;
+        };
+
+        worker.addEventListener("message", (event) => {
+          if (event.data.type === "status")
+            status.textContent = event.data.message;
+          if (event.data.type === "error") fail(event.data.message);
+          if (event.data.type === "stream") {
+            for (const patch of event.data.patches) {
+              const message = new MessageEvent("message", {
+                data: JSON.stringify(patch),
+              });
+              for (const source of streamSources) source.dispatchEvent(message);
+            }
+          }
+          if (event.data.type === "endpoint") {
+            const resolve = pendingEndpoints.get(event.data.id);
+            if (resolve) {
+              pendingEndpoints.delete(event.data.id);
+              resolve(
+                new Response(JSON.stringify(event.data.body), {
+                  status: event.data.status,
+                  headers: { "content-type": "application/json" },
+                }),
+              );
+            }
+          }
+          if (event.data.type === "snapshot") {
+            const { tree, style, store: initialStore } = event.data.payload;
+            document.head.insertAdjacentHTML("beforeend", style);
+            const store = new Store(initialStore);
+            mount(document.querySelector("#example-root"), tree, store);
+            window.setInterval(
+              () => worker.postMessage({ type: "flush" }),
+              100,
+            );
+            status.textContent = "Ready · Python model running in this browser";
+            document.documentElement.dataset.ready = "true";
+          }
+        });
+        worker.postMessage({ type: "start" });
+      } catch (error) {
+        fail(error);
+      }
+    </script>
+  </body>
+</html>

{spaday_regular_table-0.2.2 → spaday_regular_table-0.3.0}/js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spaday-regular-table",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "regular-table for spaday",
   "repository": "git@github.com:1kbgz/spaday-regular-table.git",
   "author": "1kbgz <dev@1kbgz.com>",
@@ -31,8 +31,8 @@
     "build": "npm-run-all build:prod build:types",
     "clean": "rm -rf dist playwright-report ../spaday_regular_table/extension",
     "dev": "npm-run-all -p start watch",
-    "lint": "oxlint . && oxfmt --check \"src/**/*.{js,ts,jsx,tsx,css}\" \"tests/**/*.{js,ts,jsx,tsx}\" \"*.mjs\" \"*.json\"",
-    "fix": "oxlint --fix . && oxfmt --write \"src/**/*.{js,ts,jsx,tsx,css}\" \"tests/**/*.{js,ts,jsx,tsx}\" \"*.mjs\" \"*.json\"",
+    "lint": "oxlint . && oxfmt --check \"examples/**/*.{js,html}\" \"src/**/*.{js,ts,jsx,tsx,css}\" \"tests/**/*.{js,ts,jsx,tsx}\" \"*.mjs\" \"*.json\"",
+    "fix": "oxlint --fix . && oxfmt --write \"examples/**/*.{js,html}\" \"src/**/*.{js,ts,jsx,tsx,css}\" \"tests/**/*.{js,ts,jsx,tsx}\" \"*.mjs\" \"*.json\"",
     "preinstall": "npx only-allow pnpm",
     "prepack": "npm run build",
     "start": "http-server -p 3000 -o examples/",

{spaday_regular_table-0.2.2 → spaday_regular_table-0.3.0}/js/playwright.config.js

@@ -1,5 +1,7 @@
 import { defineConfig, devices } from "@playwright/test";
 
+const pyodideOnly = process.env.SPADAY_REGULAR_TABLE_PYODIDE_ONLY === "1";
+
 export default defineConfig({
   testDir: "tests",
   fullyParallel: true,
@@ -28,11 +30,15 @@ export default defineConfig({
       reuseExistingServer: !process.env.CI,
       timeout: 120 * 1000,
     },
-    {
-      command: "python -m spaday_regular_table.example",
-      url: "http://127.0.0.1:8014",
-      reuseExistingServer: !process.env.CI,
-      timeout: 120 * 1000,
-    },
+    ...(pyodideOnly
+      ? []
+      : [
+          {
+            command: "python -m spaday_regular_table.example",
+            url: "http://127.0.0.1:8014",
+            reuseExistingServer: !process.env.CI,
+            timeout: 120 * 1000,
+          },
+        ]),
   ],
 });

spaday_regular_table-0.3.0/js/src/ts/define-guard.ts

@@ -0,0 +1,42 @@
+// The regular-table engine registers the <regular-table> custom element as an import
+// side effect, and other bundles inline their own copy of the engine (notably
+// spaday-perspective, whose viewer-datagrid plugin bundles regular-table). Whichever
+// bundle loads second would throw NotSupportedError from customElements.define and die
+// wholesale. Make define idempotent while our engine import runs so the first
+// registration of a tag wins and later duplicates are ignored instead of fatal.
+const define = customElements.define.bind(customElements);
+const lookup = customElements.get.bind(customElements);
+// names this bundle registered itself
+const ours = new Set<string>();
+
+customElements.define = (
+  name: string,
+  ctor: CustomElementConstructor,
+  options?: ElementDefinitionOptions,
+) => {
+  if (lookup(name)) return;
+  define(name, ctor, options);
+  ours.add(name);
+};
+
+/** Put the real `define` back, and warn if another copy had already registered any of `tags`, the
+ * elements this bundle serves: the page keeps that copy's, which need not match the version this
+ * package serves and its catalog describes. `served` names that version, e.g.
+ * "@awesome.me/webawesome 3.12.0". A tag that is registered, but not by this bundle, is another
+ * copy's -- whether the library skipped it just now or defines its elements later. */
+export function restoreDefine(
+  served: string,
+  tags: readonly string[] = [],
+): void {
+  customElements.define = define;
+  const taken = tags.filter((tag) => lookup(tag) && !ours.has(tag));
+  if (!taken.length) return;
+  const shown = taken
+    .slice(0, 3)
+    .map((tag) => `<${tag}>`)
+    .join(", ");
+  const more = taken.length > 3 ? ` and ${taken.length - 3} more` : "";
+  console.warn(
+    `${served}: another copy on the page already registered ${shown}${more}; the page keeps that copy's elements, which may not match this version`,
+  );
+}

{spaday_regular_table-0.2.2 → spaday_regular_table-0.3.0}/js/src/ts/index.ts

@@ -1,9 +1,10 @@
 // the guard must execute before the engine import registers its element
 import { restoreDefine } from "./define-guard";
+import { version } from "regular-table/package.json";
 import "regular-table";
 import type { RegularTableElement } from "regular-table";
 
-restoreDefine();
+restoreDefine(`regular-table ${version}`, ["regular-table"]);
 
 type Row = Record<string, unknown>;
 type CellRenderer = {

{spaday_regular_table-0.2.2 → spaday_regular_table-0.3.0}/js/tests/index.spec.js

@@ -241,3 +241,23 @@ test("survives another bundle registering regular-table first", async ({
   expect(r.wrapperDefined).toBe(true);
   expect(r.defineRestored).toBe(true); // the guard did not leak past the engine import
 });
+
+test("warns, naming what it serves, when another copy registered its elements first", async ({
+  page,
+}) => {
+  // the page keeps the first registration, so the loser says which elements are not its own
+  const warnings = [];
+  page.on("console", (message) => {
+    if (message.type() === "warning") warnings.push(message.text());
+  });
+  await page.addInitScript(() => {
+    customElements.define("regular-table", class extends HTMLElement {});
+  });
+  await page.goto("/dist/index.html");
+  await expect
+    .poll(() => warnings.find((text) => text.includes("<regular-table>")))
+    .toMatch(/ \d+\.\d+\.\d+\S*: another copy on the page already registered /);
+  expect(warnings.find((text) => text.includes("<regular-table>"))).toContain(
+    "regular-table ",
+  );
+});

spaday_regular_table-0.3.0/js/tests/pyodide.spec.js

@@ -0,0 +1,29 @@
+import fs from "fs";
+import { expect, test } from "@playwright/test";
+
+const built = fs.existsSync("dist/lite/index.html");
+
+test("runs the complete example in Pyodide", async ({ page }) => {
+  test.skip(!built, "run `make pyodide-example` first");
+  test.setTimeout(180_000);
+
+  await page.goto("/dist/lite/index.html");
+  await page.waitForFunction(
+    () =>
+      document.documentElement.dataset.ready === "true" ||
+      document.querySelector("#pyodide-status")?.textContent ===
+        "Unable to start",
+    undefined,
+    { timeout: 150_000 },
+  );
+  await expect(page.locator("html")).toHaveAttribute("data-ready", "true");
+  await expect(page.getByText("Regular Table", { exact: true })).toBeVisible();
+  await expect(page.getByText("100,000", { exact: true })).toBeVisible();
+  await expect(page.locator("spaday-regular-table")).toBeVisible();
+
+  await page.getByRole("button", { name: "Update first row" }).click();
+  await expect(page.locator(".action-status")).toContainText("Server updated");
+  await expect(page.locator("#stream-status")).toHaveText(
+    "Applied server row patch",
+  );
+});

{spaday_regular_table-0.2.2 → spaday_regular_table-0.3.0}/pyproject.toml

@@ -13,7 +13,7 @@ authors = [
 description = "regular-table for spaday"
 readme = "README.md"
 license = { text = "Apache-2.0" }
-version = "0.2.2"
+version = "0.3.0"
 requires-python = ">=3.11"
 keywords = []
 
@@ -30,7 +30,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "spaday>=0.6.0,<1.0",
+    "spaday>=0.11.1,<1.0",
 ]
 
 [project.entry-points."spaday.component_packages"]
@@ -69,7 +69,7 @@ Repository = "https://github.com/1kbgz/spaday-regular-table"
 Homepage = "https://github.com/1kbgz/spaday-regular-table"
 
 [tool.bumpversion]
-current_version = "0.2.2"
+current_version = "0.3.0"
 commit = true
 tag = true
 commit_args = "-s"

{spaday_regular_table-0.2.2 → spaday_regular_table-0.3.0}/spaday_regular_table/__init__.py

@@ -1,12 +1,13 @@
+import json
 from pathlib import Path
 from typing import Any
 
-from spaday import ComponentPackage
+from spaday import ComponentPackage, Token
 from spaday.component import Child
 
 from .components import SpadayRegularTable
 
-__version__ = "0.2.2"
+__version__ = "0.3.0"
 
 
 class RegularTable(SpadayRegularTable):
@@ -39,24 +40,27 @@ class RegularTable(SpadayRegularTable):
         )
 
 
+# the exact version of each JS library the package serves, written by its JS build
+_VERSIONS = Path(__file__).parent / "extension" / "versions.json"
+
 package = ComponentPackage(
     name="regular-table",
     assets_dir=Path(__file__).parent / "extension",
     assets=(("css", "css/material.css"), ("css", "css/theme.css"), ("js", "cdn/index.js")),
     components=(RegularTable,),
+    provides=json.loads(_VERSIONS.read_text(encoding="utf-8")) if _VERSIONS.exists() else {},
 )
 
 
-#: ``css()`` kwarg → (CSS custom property, what it controls), in the shape of
-#: :data:`spaday.theme.SHELL_TOKENS`. Each defaults to the shell token it belongs to, so re-theming
+#: ``css()`` kwarg → (CSS custom property, what it controls). Each defaults to the shell token it belongs to, so re-theming
 #: the shell carries the table with it; set these to theme the table alone.
 TOKENS = {
-    "spa_regular_table_text": ("--spa-regular-table-text", "cell text color (defaults to --spa-muted)"),
-    "spa_regular_table_border": ("--spa-regular-table-border", "header rule under the last header row (defaults to --spa-border)"),
-    "spa_regular_table_row_hover": ("--spa-regular-table-row-hover", "hovered row background (defaults to --spa-surface-2)"),
-    "spa_regular_table_row_hover_text": ("--spa-regular-table-row-hover-text", "hovered row text color"),
-    "spa_regular_table_scrollbar": ("--spa-regular-table-scrollbar", "scrollbar thumb color"),
-    "spa_regular_table_scrollbar_hover": ("--spa-regular-table-scrollbar-hover", "scrollbar thumb color while hovered"),
+    "spa_regular_table_text": Token("--spa-regular-table-text", "cell text color", fallback="--spa-muted"),
+    "spa_regular_table_border": Token("--spa-regular-table-border", "header rule under the last header row", fallback="--spa-border"),
+    "spa_regular_table_row_hover": Token("--spa-regular-table-row-hover", "hovered row background", fallback="--spa-surface-2"),
+    "spa_regular_table_row_hover_text": Token("--spa-regular-table-row-hover-text", "hovered row text color"),
+    "spa_regular_table_scrollbar": Token("--spa-regular-table-scrollbar", "scrollbar thumb color"),
+    "spa_regular_table_scrollbar_hover": Token("--spa-regular-table-scrollbar-hover", "scrollbar thumb color while hovered"),
 }
 
 __all__ = ["TOKENS", "RegularTable", "package"]