spiderly 19.13.0 → 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';
@@ -340,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
@@ -348,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`
@@ -397,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();
@@ -558,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
@@ -845,6 +870,9 @@ export interface TableView<TFilters = any, TRow = any> {
     /**
      * 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;
     /**
@@ -871,7 +899,9 @@ export interface TableView<TFilters = any, TRow = any> {
      *
      * 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`).
+     * 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;
     /**

package/package.json

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