Merge pull request #329 from timkpaine/tkp/spaday-parity

Match legacy defaults, apply theme

Author: timkpaine

csp_gateway/server/modules/web/perspective.py

@@ -750,6 +750,7 @@ def ui(self, app: "GatewayUI") -> None:
                 tables=list(tables.keys()),
                 default_tables=self._select_default_layout_tables(tables),
                 layouts=layouts,
+                schemas=tables,
             ),
         )
         default_view = self.default_layout or "__default__"

csp_gateway/server/web/spaday_ui.py

@@ -284,15 +284,20 @@ def perspective_panel(
         tables: list[str] | None = None,
         default_tables: list[str] | None = None,
         layouts: dict[str, str] | None = None,
+        schemas: dict[str, dict[str, str]] | None = None,
     ) -> Any:
         """A Perspective workspace panel (the primary data view), bound to the theme + `view` state.
 
         Data rides Perspective's own websocket at ``route``; the panel only carries the workspace
         layout/theme config. ``default_tables`` are the ones the generated layout opens, defaulting
-        to all of ``tables``. Add it to `Region.MAIN`.
+        to all of ``tables``. ``schemas`` (table name -> column name -> type) lets the generated
+        layout apply per-table defaults (timestamp sort, hidden id column). Add it to `Region.MAIN`.
         """
         tables = list(tables or [])
-        default_layout = self._default_layout(list(default_tables) if default_tables is not None else tables)
+        default_layout = self._default_layout(
+            list(default_tables) if default_tables is not None else tables,
+            schemas=schemas,
+        )
         layout_expr: Any = default_layout
         for name, layout_json in (layouts or {}).items():
             try:
@@ -448,13 +453,23 @@ def _form_overrides(overrides: dict[str, dict[str, Any]], form_field_cls: Any) -
         return result
 
     @staticmethod
-    def _default_layout(tables: list[str]) -> dict[str, Any]:
-        """A perspective workspace config that shows every table in its own datagrid tab."""
+    def _default_layout(tables: list[str], schemas: dict[str, dict[str, str]] | None = None) -> dict[str, Any]:
+        """A perspective workspace config that shows every table in its own datagrid tab.
+
+        With ``schemas`` (table name -> column name -> type), panels match the legacy UI's defaults:
+        sorted by ``timestamp`` descending when the table has one, and the ``id`` column hidden.
+        """
         panels: dict[str, Any] = {}
         panel_ids: list[str] = []
         for i, table in enumerate(tables):
             panel_id = f"CSP_GATEWAY_{i}"
-            panels[panel_id] = {"table": table, "plugin": "Datagrid", "title": table}
+            panel: dict[str, Any] = {"table": table, "plugin": "Datagrid", "title": table}
+            schema = (schemas or {}).get(table) or {}
+            if "timestamp" in schema:
+                panel["sort"] = [["timestamp", "desc"]]
+            if "id" in schema:
+                panel["columns"] = [column for column in schema if column != "id"]
+            panels[panel_id] = panel
             panel_ids.append(panel_id)
         return {
             "layout": {"type": "tab-layout", "tabs": panel_ids, "selected": 0},
@@ -773,7 +788,11 @@ def mount(self) -> None:
             layout="installed",
             wire=wire,
             routes=routes,
-            store={"dark": False, **self._store_seeds},
+            # `dark` matches the browser preference at boot (client-evaluated, like the legacy UI's
+            # prefers-color-scheme detection), and a manual toggle is persisted per browser and takes
+            # precedence on later loads.
+            store={"dark": Js('matchMedia("(prefers-color-scheme: dark)").matches'), **self._store_seeds},
+            persist={"dark": "csp-gateway:dark"},
             # Emitted after the component packages' own CSS, so a custom stylesheet can override the
             # shell palette, and before `head`, which carries only document resets.
             stylesheets=custom_css,

csp_gateway/tests/server/web/test_spaday_ui.py

@@ -250,6 +250,56 @@ def test_one_datagrid_panel_per_table(self):
             "CSP_GATEWAY_1": {"table": "fills", "plugin": "Datagrid", "title": "fills"},
         }
 
+    def test_schemas_add_legacy_parity_sort_and_columns(self):
+        # Legacy-UI parity: timestamp sorts descending and the id column is hidden.
+        from csp_gateway.server.web.spaday_ui import GatewayUI
+
+        layout = GatewayUI._default_layout(
+            ["orders"],
+            schemas={"orders": {"id": "string", "timestamp": "datetime", "price": "float"}},
+        )
+        panel = layout["panels"]["CSP_GATEWAY_0"]
+        assert panel["sort"] == [["timestamp", "desc"]]
+        assert panel["columns"] == ["timestamp", "price"]
+
+    def test_schema_without_timestamp_or_id_stays_bare(self):
+        from csp_gateway.server.web.spaday_ui import GatewayUI
+
+        layout = GatewayUI._default_layout(["orders"], schemas={"orders": {"price": "float"}})
+        panel = layout["panels"]["CSP_GATEWAY_0"]
+        assert "sort" not in panel
+        assert "columns" not in panel
+
+
+class TestDarkBoot:
+    """The page seeds `dark` from the browser's prefers-color-scheme, like the legacy UI."""
+
+    @pytest.fixture(scope="class")
+    def gateway(self, free_port):
+        return Gateway(
+            modules=[ExampleModule(), MountRestRoutes(force_mount_all=True)],
+            channels=ExampleChannels(),
+            settings=GatewaySettings(PORT=free_port, UI_PROVIDER="spaday"),
+        )
+
+    @pytest.fixture(scope="class")
+    def client(self, gateway):
+        gateway.start(rest=True, ui=True, _in_test=True)
+        try:
+            yield TestClient(gateway.web_app.get_fastapi())
+        finally:
+            gateway.stop()
+
+    def test_dark_seed_is_client_evaluated(self, client: TestClient):
+        page = client.get("/").text
+        assert '"dark": (matchMedia("(prefers-color-scheme: dark)").matches)' in page
+
+    def test_dark_choice_persists_across_reloads(self, client: TestClient):
+        # A manual toggle is stored and overrides the browser preference on the next load (legacy parity).
+        page = client.get("/").text
+        assert 'localStorage.getItem("csp-gateway:dark")' in page
+        assert 'store.subscribe("dark", (v) => { try { localStorage.setItem("csp-gateway:dark", JSON.stringify(v)); } catch {} });' in page
+
 
 class TestSpadayPerspectiveLayoutActions:
     @pytest.fixture(scope="class")