spiderly 19.12.4 → 19.14.0

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

@@ -7,6 +7,7 @@ import { Table, TableLazyLoadEvent } from 'primeng/table';
 import { Observable } from 'rxjs';
 import { CellTemplateContext, SpiderlyCellTemplateDirective } from '../../directives/spiderly-cell-template.directive';
 import { Filter } from '../../entities/filter';
+import { FilterRule } from '../../entities/filter-rule';
 import { LazyLoadSelectedIdsResult } from '../../entities/lazy-load-selected-ids-result';
 import { PaginatedResult } from '../../entities/paginated-result';
 import { PrimengOption } from '../../entities/primeng-option';
@@ -248,6 +249,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
@@ -338,6 +341,7 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * reading exactly the keys they already wrote.
      */
     private get viewScope();
+    private viewScopeOf;
     /**
      * Where the applied filters live. Follows `stateStorage` rather than the layout's always-local
      * rule, because that is where they lived before the bar took them off the header: PrimeNG's
@@ -346,6 +350,7 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * durable preference like a column's width.
      */
     private get filtersStateKey();
+    private filtersStateKeyOf;
     private get filterStorage();
     /**
      * Where the active view id lives. Deliberately NOT view-scoped — it is the input `viewScope`
@@ -376,6 +381,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;
@@ -390,6 +400,9 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * the empty state the operator left — they cleared it, and F5 must give the cleared state
      * back. On a table with no views, `view` is null and this is a plain restore of the
      * `persistAppliedFilters` snapshot.
+     *
+     * `viewFilterPayload` passes a scratch store and another view's key, to read what entering
+     * that view would send.
      */
     private enterViewFilters;
     private get layoutStateKey();
@@ -551,6 +564,25 @@ export declare class SpiderlyDataTableComponent implements OnInit, OnChanges, Af
      * view's filters are in place.
      */
     selectView(view: TableView): void;
+    /**
+     * The `filters` payload a view's own list request carries — the same shape the store's
+     * `toFilterPayload()` emits — so a consumer's count query can narrow each view by the bar
+     * filters the operator saved on it, and a `TableView.count` stays the number of rows that tab
+     * lists: on screen for the active view, after a click for the others (spiderly#439).
+     *
+     * - The ACTIVE view answers with the live filters. Not with what a click would enter: clicking
+     *   the active tab re-asks its question when the operator has cleared the bar, but the list on
+     *   screen, and so its count, has not.
+     * - Any other view answers with what a click would enter (`enterViewFilters`): the filters
+     *   saved on it, else its `apply` — always `apply` for a transient view. That runs on a scratch
+     *   `createFilterStore` of the same declarations, so nothing switches, persists or re-queries.
+     *   Untracked: the scratch store's signal writes would otherwise make a read inside a
+     *   `computed` throw NG0600.
+     *
+     * `{}` on a table without `[filters]`, whose requests carry none; `null` for an id that is not
+     * in `[views]`.
+     */
+    viewFilterPayload(viewId: string): Record<string, FilterRule[]> | null;
     /**
      * The filter this column stands for. Defaults to the column's own `field`, because a store id
      * IS a backend property name — `toFilterPayload` emits it straight into `Filter.filters`. So
@@ -752,6 +784,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,12 +864,15 @@ 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;
     /**
      * Sets the filters this view asks for. Receives the table's own store, so a consumer writes it
      * with the store's typing. Called on a CLEARED store: a view is a state, not an addition.
+     *
+     * `viewFilterPayload` also calls it, on a scratch store of the same declarations, to read what
+     * entering the view would send, so it writes into the store it receives and nothing else.
      */
     apply?: (filters: TFilters) => void;
     /**
@@ -851,10 +888,35 @@ 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`). For a count that
+     * honors the bar filters an operator saved on each view, send each view's
+     * `viewFilterPayload(id)` with that query.
+     */
+    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 +963,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.4",
+  "version": "19.14.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