spiderly 19.12.3 → 19.13.0

package/lib/components/spiderly-data-table/spiderly-data-table.component.d.ts

@@ -248,6 +248,8 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
     private get columnsStateKey();
     /** Actions columns always render; data columns follow the override, then declared default. */
     isColumnVisible(col: Column): boolean;
+    /** The declared default in the current context: the active view's `columns`, then `Column.visible`. */
+    private isDeclaredVisible;
     /**
      * `cols` in the operator's order. A field the stored order has never seen — a column added in a
      * later release — sorts to the END rather than displacing a layout someone built by hand
@@ -376,6 +378,11 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * overwrites it, the operator's own choice wins by construction. Accepted cost of adopting
      * late instead of holding the first request: a brief flash of the seeded view's rows and a
      * second request when the late view lands.
+     *
+     * Only a view this change BROUGHT is adopted. A consumer rebuilds `[views]` on every list load
+     * to refresh `TableView.count`, and under `stateStorage: 'local'` the key can name a view the
+     * operator picked in another browser tab — adopting on every change switched this tab's view
+     * at the next count refresh (spiderly#430).
      */
     private adoptStoredView;
     private viewById;
@@ -752,6 +759,8 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
     getRowData(rowData: any, col: Column): string;
     colTrackByFn(index: any, item: any): any;
     actionTrackByFn(index: any, item: Action): string;
+    /** By id: a count refresh rebuilds `[views]` as new objects, and must not re-create the focused tab. */
+    viewTrackByFn(index: number, view: TableView): string;
     exportListToExcel(): void;
     /**
      * Clears the FILTERS — and nothing else (2026-09-06, grilled). It used to also reach the
@@ -830,7 +839,7 @@ export declare class Action {
  * fixed daily jobs, shared built-in views cover the work, while personal saved views would drift
  * into five variants of the same question. Personal LAYOUT choices still persist on top, per view.
  */
-export interface TableView<TFilters = any> {
+export interface TableView<TFilters = any, TRow = any> {
     id: string;
     label: string;
     /**
@@ -851,10 +860,33 @@ export interface TableView<TFilters = any> {
      * first" IS the work list, not a reading preference). Entering the view applies it; the
      * tri-state un-sort and Clear filters return to it instead of the table default; an operator's
      * own sort overrides it, persisted per view on store tables (decision 10's sort half). A view
-     * declaring none keeps whatever ordering the grid already has, exactly as before this field
-     * existed.
+     * declaring none falls back to the table's `defaultSortField`, else unsorted — it never keeps
+     * the previous view's ordering (`applyViewSort`).
      */
     sort?: SortMeta[];
+    /**
+     * How many rows the view holds, shown as a badge beside its label so an operator sees which
+     * work list has something in it without clicking through every tab (Polaris IndexFilters
+     * carries the same badge). `null` or absent shows no badge; `0` shows one.
+     *
+     * The table never computes it: the consumer runs its own count query and hands the number in,
+     * typically by rebuilding `[views]` after every list load. Such a rebuild is safe — it neither
+     * re-enters the active view nor sends a request (see `adoptStoredView`).
+     */
+    count?: number | null;
+    /**
+     * The view's own column defaults, as field → visible: `{ why: true, location: false }` shows
+     * `why` and hides `location` in this view only, overriding their `Column.visible`. A column the
+     * map does not name keeps its `Column.visible`, so a column added to the table later shows up
+     * in every view that does not hide it. Place a column a view swaps in next to the one it
+     * replaces in `cols`, and it takes that column's place.
+     *
+     * The operator's own per-view choices still win, and are stored only where they differ from
+     * this declaration, so a changed declaration reaches every operator who never touched that
+     * column; Reset returns to it. A `lockVisible` column always shows, whatever the map says.
+     * Rebuilding `[views]` with a changed map re-renders the active view's columns.
+     */
+    columns?: Partial<Record<string & keyof TRow, boolean>>;
 }
 export declare class Column<T = any> {
     name?: string;
@@ -901,6 +933,7 @@ export declare class Column<T = any> {
     /**
      * Whether the column is initially rendered. Defaults to `true`. Declare `visible: false` for
      * columns that should be available in the column chooser but hidden until the user reveals them.
+     * A view overrides it for itself through {@link TableView.columns}.
      */
     visible?: boolean;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spiderly",
-  "version": "19.12.3",
+  "version": "19.13.0",
   "author": "Filip Trivan",
   "license": "MIT",
   "description": "Spiderly Angular Library to use in combination with Spiderly.",

package/styles/components/spiderly-data-table/spiderly-data-table.component.scss

@@ -149,6 +149,16 @@
     background: var(--p-content-hover-background);
   }
 
+  // Inherits the tab's colour, so the active tab's count reads as part of the active tab.
+  .table-view-count {
+    margin-left: 6px;
+    padding: 0 6px;
+    border-radius: 999px;
+    background: var(--p-content-border-color);
+    font-size: 0.75rem;
+    font-variant-numeric: tabular-nums;
+  }
+
   // The left edge that survives a horizontal scroll. Geometry only here: the opaque background
   // lives on the BODY cells below, because the header th already gets an opaque
   // header.cell.background from PrimeNG's own th rule. Painting the row palette on the whole