@firestitch/report 18.10.2 → 18.11.1

package/app/reports/components/report-canvas/report-canvas.component.d.ts

@@ -46,7 +46,6 @@ export declare class ReportCanvasComponent implements OnChanges, AfterViewInit {
     readonly masterMode: WritableSignal<boolean>;
     groups: Map<number, ReportFilterGroup>;
     readonly selectedComponentId: WritableSignal<number>;
-    readonly appliedVersion: import("@angular/core").Signal<number>;
     readonly activePageComponents: import("@angular/core").Signal<ReportComponent[]>;
     readonly masterComponents: import("@angular/core").Signal<ReportComponent[]>;
     readonly pageTokens: import("@angular/core").Signal<TextTokenContext>;

package/app/reports/data/report.data.d.ts

@@ -4,10 +4,8 @@ import { ReportExportLine } from '../interfaces/report-export-line.interface';
 import { ReportFilterGroupChanges } from '../interfaces/report-filter-group-changes.interface';
 import { ReportFilterOptionsRequest } from '../interfaces/report-filter-options-request.interface';
 import { ReportFilterOptions } from '../interfaces/report-filter-options.interface';
-import { ReportViewCreate } from '../interfaces/report-view-create.interface';
-import { ReportViewDeleted } from '../interfaces/report-view-deleted.interface';
-import { ReportView } from '../interfaces/report-view.interface';
-import { ReportViews } from '../interfaces/report-views.interface';
+import { ReportSavedFilterChanges } from '../interfaces/report-saved-filter-changes.interface';
+import { ReportSavedFilter } from '../interfaces/report-saved-filter.interface';
 import { ChartGranularity, ComponentDataState, ComponentExportResponse, ReportComponentSql, ReportLocales, ReportPageValue, ReportTree, ResolvedFilterValue } from '../interfaces/report.interface';
 import * as i0 from "@angular/core";
 export declare class ReportData<T = any> {
@@ -58,7 +56,7 @@ export declare class ReportData<T = any> {
     componentData(reportId: number, componentId: number, filters?: ResolvedFilterValue[], state?: ComponentDataState, isExport?: boolean, config?: RequestConfig): Observable<T>;
     pageValues(reportId: number, pageId: number, filters?: ResolvedFilterValue[], isExport?: boolean, config?: RequestConfig, matchAnyGroupIds?: number[]): Observable<ReportPageValue[]>;
     exportComponent(reportId: number, componentId: number, filters?: ResolvedFilterValue[], state?: ComponentDataState, title?: string, config?: RequestConfig): Observable<ComponentExportResponse>;
-    exportReport(reportId: number, filters?: ResolvedFilterValue[], pageId?: number | null, frequency?: ChartGranularity | null, filterLines?: ReportExportLine[], states?: Record<number, ComponentDataState>, viewId?: number | null, viewChanged?: boolean, titles?: Record<number, string>, config?: RequestConfig): Observable<T>;
+    exportReport(reportId: number, filters?: ResolvedFilterValue[], pageId?: number | null, frequency?: ChartGranularity | null, filterLines?: ReportExportLine[], states?: Record<number, ComponentDataState>, titles?: Record<number, string>, config?: RequestConfig): Observable<T>;
     filterOptions(reportId: number, filterId: number, config?: RequestConfig): Observable<T>;
     componentSql(reportId: number, componentId: number, config?: RequestConfig): Observable<ReportComponentSql>;
     componentColumns(reportId: number, componentId: number, config?: RequestConfig): Observable<T>;
@@ -90,13 +88,11 @@ export declare class ReportData<T = any> {
     }, config?: RequestConfig): Observable<T>;
     updateFilterGroup(reportId: number, groupId: number, changes: ReportFilterGroupChanges, config?: RequestConfig): Observable<T>;
     filterOptionsNarrowed(reportId: number, filterId: number, body: ReportFilterOptionsRequest, config?: RequestConfig): Observable<ReportFilterOptions>;
-    views(reportId: number, config?: RequestConfig): Observable<ReportViews>;
-    view(reportId: number, reportViewId: number, config?: RequestConfig): Observable<ReportView>;
-    createView(reportId: number, view: ReportViewCreate, config?: RequestConfig): Observable<ReportView>;
-    updateView(reportId: number, reportViewId: number, changes: Partial<Pick<ReportViewCreate, 'name' | 'config'>>, config?: RequestConfig): Observable<ReportView>;
-    deleteView(reportId: number, reportViewId: number, config?: RequestConfig): Observable<ReportViewDeleted>;
-    shareView(reportId: number, reportViewId: number, shared: boolean, config?: RequestConfig): Observable<ReportView>;
-    setViewDefault(reportId: number, reportViewId: number, personalDefault: boolean, config?: RequestConfig): Observable<ReportView>;
+    savedFilters(reportId: number, config?: RequestConfig): Observable<ReportSavedFilter[]>;
+    createSavedFilter(reportId: number, savedFilter: Required<ReportSavedFilterChanges>, config?: RequestConfig): Observable<ReportSavedFilter>;
+    updateSavedFilter(reportId: number, reportSavedFilterId: number, changes: ReportSavedFilterChanges, config?: RequestConfig): Observable<ReportSavedFilter>;
+    deleteSavedFilter(reportId: number, reportSavedFilterId: number, config?: RequestConfig): Observable<ReportSavedFilter>;
+    saveSavedFilterPositions(reportId: number, reportSavedFilterIds: number[], config?: RequestConfig): Observable<ReportSavedFilter[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ReportData<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ReportData<any>>;
 }

package/app/reports/export/report-export-collector.service.d.ts

@@ -91,7 +91,6 @@ export declare class ReportExportCollectorService {
     private _reportData;
     private _filterState;
     private _filterOptions;
-    private _views;
     collect(report: Report, listRows: number): Observable<CollectedReport>;
     snapshot(report: Report): ReportExportSnapshot;
     exportWording(report: Report, snapshot: ReportExportSnapshot, pageId?: number | null): Observable<ReportExportWording>;

package/app/reports/export/report-filter-lines.d.ts

@@ -5,7 +5,6 @@ import { ReportExportLinesInput } from '../interfaces/report-export-lines-input.
 import { ReportFilterLineContext } from '../interfaces/report-filter-line-context.interface';
 import { ReportFilterLineForm } from '../interfaces/report-filter-line-form.type';
 import { ReportFilterMatch } from '../interfaces/report-filter-match.type';
-import { ReportViewSummary } from '../interfaces/report-view-summary.interface';
 import { FilterGroupValue, Report, ReportComponent, ReportFilterGroup, ReportFormatContext } from '../interfaces/report.interface';
 export declare const MATCH_ANY_CHIP = "Match: any filter";
 export declare const MATCH_ANY_LINE = "Filters in the report bar: match any";
@@ -16,6 +15,5 @@ export declare function excludes(value: FilterGroupValue | null | undefined): bo
 export declare function valuePicks(value: FilterGroupValue | null | undefined): unknown[];
 export declare function matchLineText(match: ReportFilterMatch | null | undefined, form: ReportFilterLineForm): string | null;
 export declare function drillLineText(component: Pick<ReportComponent, 'title'>, path: readonly ReportDrillStep[], formatContext: Pick<ReportFormatContext, 'locale'>): string;
-export declare function viewLineText(view: Pick<ReportViewSummary, 'name' | 'shared'> | null | undefined, changed: boolean): string | null;
 export declare function exportLines(input: ReportExportLinesInput): Observable<ReportExportLine[]>;
 export declare function exportGroups(report: Report, pageId: number | null): ReportFilterGroup[];

package/app/reports/interfaces/report-chat-viewer-state.interface.d.ts

@@ -10,8 +10,6 @@ export interface ReportChatViewerState {
     selectedComponentId: number | null;
     filters: ReportChatViewerFilter[];
     match?: ReportFilterMatch;
-    viewId?: number | null;
-    viewChanged?: boolean;
     crossFilters?: ReportChatViewerCrossFilter[];
     drills?: ReportChatViewerDrill[];
     detail?: ReportChatViewerDetail | null;

package/app/reports/interfaces/report-export-snapshot.interface.d.ts

@@ -1,8 +1,8 @@
-import { ReportViewConfig } from './report-view-config.interface';
+import { ReportStateSnapshot } from './report-state-snapshot.interface';
 import { ReportViewerFeature } from './report-viewer-feature.type';
 import { ChartGranularity, ComponentDataState, FilterGroupValue, ReportFormatContext, ReportRelativeRange, ResolvedFilterValue } from './report.interface';
 export interface ReportExportSnapshot {
-    view: ReportViewConfig;
+    state: ReportStateSnapshot;
     values: Record<number, FilterGroupValue>;
     presets: Record<number, ReportRelativeRange>;
     filters: Record<number, ResolvedFilterValue[]>;
@@ -11,5 +11,4 @@ export interface ReportExportSnapshot {
     frequency: ChartGranularity | null;
     features: ReportViewerFeature[];
     formatContext: ReportFormatContext;
-    viewLine: string | null;
 }

package/app/reports/interfaces/report-saved-filter-changes.interface.d.ts

@@ -0,0 +1,4 @@
+export interface ReportSavedFilterChanges {
+    name?: string;
+    filters?: Record<string, unknown>;
+}

package/app/reports/interfaces/report-saved-filter.interface.d.ts

@@ -0,0 +1,6 @@
+export interface ReportSavedFilter {
+    id: number;
+    name: string;
+    filters: Record<string, unknown>;
+    order?: number;
+}

package/app/reports/interfaces/{report-view-config.interface.d.ts → report-state-snapshot.interface.d.ts}

@@ -1,8 +1,7 @@
 import { ReportFilterMatch } from './report-filter-match.type';
 import { ReportTileState } from './report-tile-state.interface';
 import { ChartGranularity, FilterGroupDefault } from './report.interface';
-export interface ReportViewConfig {
-    v: number;
+export interface ReportStateSnapshot {
     pageId?: number;
     groupBy?: ChartGranularity;
     match?: ReportFilterMatch;

package/app/reports/interfaces/report-viewer-feature.type.d.ts

@@ -1 +1 @@
-export type ReportViewerFeature = 'excludeValues' | 'numberRange' | 'matchAny' | 'pageScope' | 'cascadingOptions' | 'scopeFilters' | 'views' | 'drill' | 'crossFilter' | 'detail';
+export type ReportViewerFeature = 'excludeValues' | 'numberRange' | 'matchAny' | 'pageScope' | 'cascadingOptions' | 'scopeFilters' | 'drill' | 'crossFilter' | 'detail';

package/app/reports/report-chat-viewer-state.d.ts

@@ -1,8 +1,8 @@
 import { ReportChatViewerDrill } from './interfaces/report-chat-viewer-drill.interface';
 import { ReportChatViewerState } from './interfaces/report-chat-viewer-state.interface';
-import { ReportViewConfig } from './interfaces/report-view-config.interface';
+import { ReportStateSnapshot } from './interfaces/report-state-snapshot.interface';
 import { ReportLocaleTag } from './interfaces/report.interface';
 export declare const CHAT_DRILLS_MAX = 10;
 export declare const CHAT_LABEL_MAX = 100;
-export declare function chatViewerMatch(snapshot: ReportViewConfig): Pick<ReportChatViewerState, 'match'>;
-export declare function chatViewerDrills(snapshot: ReportViewConfig, locale: ReportLocaleTag): ReportChatViewerDrill[];
+export declare function chatViewerMatch(snapshot: ReportStateSnapshot): Pick<ReportChatViewerState, 'match'>;
+export declare function chatViewerDrills(snapshot: ReportStateSnapshot, locale: ReportLocaleTag): ReportChatViewerDrill[];

package/app/reports/report-saved-filters.d.ts

@@ -0,0 +1,3 @@
+import { ReportFilterGroup } from './interfaces/report.interface';
+export declare function savedFilterGroups(groups: readonly ReportFilterGroup[] | null | undefined): ReportFilterGroup[];
+export declare function savedFilterValues(filters: Record<string, unknown> | null | undefined, groups: readonly ReportFilterGroup[]): Record<string, unknown>;

package/app/reports/report-state.d.ts

@@ -0,0 +1,15 @@
+import { ReportDrillStep } from './interfaces/report-drill-step.interface';
+import { ReportStateSnapshot } from './interfaces/report-state-snapshot.interface';
+import { ChartGranularity, FilterGroupDefault, FilterGroupValue, ReportFilterType, ReportRelativeRange } from './interfaces/report.interface';
+export declare const DRILL_MAX_DEPTH = 5;
+export declare const RELATIVE_RANGE_NAMES: ReportRelativeRange[];
+export declare function isRelativeRange(name: unknown): name is ReportRelativeRange;
+export declare function isChartGranularity(value: unknown): value is ChartGranularity;
+export declare function isCalendarDay(text: string): boolean;
+export declare function numberFromText(text: string): number | null;
+export declare function toStoredGroupValue(type: ReportFilterType, value: FilterGroupValue | null | undefined): FilterGroupDefault | null;
+export declare function stateDiffers(defaults: ReportStateSnapshot, current: ReportStateSnapshot): boolean;
+export declare function sameStoredGroupValue(a: FilterGroupDefault | null | undefined, b: FilterGroupDefault | null | undefined): boolean;
+export declare function cleanDrillPath(path: readonly unknown[] | null | undefined): ReportDrillStep[];
+export declare function sameDrillPath(a: readonly ReportDrillStep[] | null | undefined, b: readonly ReportDrillStep[] | null | undefined): boolean;
+export declare function finiteNumber(value: unknown): number | undefined;

package/app/reports/services/report-filter-state.service.d.ts

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { ReportChatViewerFilter } from '../interfaces/report-chat-viewer-filter.interface';
 import { ReportDrillStep } from '../interfaces/report-drill-step.interface';
 import { ReportFilterMatch } from '../interfaces/report-filter-match.type';
-import { ReportViewConfig } from '../interfaces/report-view-config.interface';
+import { ReportStateSnapshot } from '../interfaces/report-state-snapshot.interface';
 import { ChartGranularity, FilterGroupDefault, FilterGroupValue, Report, ReportComponent, ReportFilterGroup, ReportFormatContext, ReportRelativeRange, ReportSort, ResolvedFilterValue } from '../interfaces/report.interface';
 import { ComponentDataState } from '../interfaces/report.interface';
 import * as i0 from "@angular/core";
@@ -22,14 +22,12 @@ export declare class ReportFilterStateService {
     readonly formatContext: import("@angular/core").WritableSignal<ReportFormatContext>;
     readonly listHidden: import("@angular/core").WritableSignal<ReadonlyMap<number, readonly string[]>>;
     readonly stateVersion: import("@angular/core").Signal<number>;
-    readonly appliedVersion: import("@angular/core").Signal<number>;
     readonly listSortResets: import("@angular/core").Signal<ReadonlyMap<number, number>>;
     readonly page: import("@angular/core").Signal<number>;
     readonly match: import("@angular/core").Signal<ReportFilterMatch>;
     readonly viewerFeatures: import("@angular/core").Signal<import("@firestitch/report").ReportViewerFeature[]>;
     readonly report: import("@angular/core").Signal<Report>;
-    readonly base: import("@angular/core").Signal<ReportViewConfig>;
-    readonly viewChanged: import("@angular/core").Signal<boolean>;
+    readonly differsFromDefaults: import("@angular/core").Signal<boolean>;
     private _values;
     private _groups;
     private _sessionDisabled;
@@ -45,14 +43,12 @@ export declare class ReportFilterStateService {
     private _stateChanged$;
     private _revision;
     private _stateVersion;
-    private _appliedVersion;
     private _listSortResets;
     private _report;
     private _pageId;
     private _match;
     private _drills;
     private _drillChanged$;
-    private _baseConfig;
     private _temporary;
     init(report: Report): void;
     value(groupId: number): FilterGroupValue | undefined;
@@ -86,14 +82,11 @@ export declare class ReportFilterStateService {
     setDrill(componentId: number, path: readonly ReportDrillStep[]): void;
     drillChanges(componentId: number): Observable<void>;
     adoptDrill(componentId: number, path: readonly ReportDrillStep[]): boolean;
-    snapshot(): ReportViewConfig;
-    authoredConfig(): ReportViewConfig;
-    apply(config: ReportViewConfig | null, pageId?: number | null): void;
-    resetToBase(): void;
-    setBaseToScreen(): void;
-    clearBase(): void;
-    resetGroupsToBase(groupIds: readonly number[]): void;
-    groupsDifferFromBase(groupIds: readonly number[]): boolean;
+    snapshot(): ReportStateSnapshot;
+    authoredConfig(): ReportStateSnapshot;
+    resetToDefaults(): void;
+    resetGroupsToDefaults(groupIds: readonly number[]): void;
+    groupsDifferFromDefaults(groupIds: readonly number[]): boolean;
     tileState(component: ReportComponent): ComponentDataState;
     livePreset(groupId: number): ReportRelativeRange | null;
     private _resolvedFields;
@@ -108,22 +101,13 @@ export declare class ReportFilterStateService {
     private _relativeRange;
     private _snapshotGroups;
     private _snapshotTiles;
-    private _setBase;
-    private _applyLayer;
-    private _applyGroups;
-    private _applyGroup;
     private _seedAuthored;
     private _clearTiles;
-    private _applyTile;
-    private _applyListTile;
     private _setDrillPath;
-    private _applyPage;
-    private _notifyApplied;
+    private _notifyReset;
     private _tiles;
     private _isChart;
-    private _pruneViewState;
-    private _pruneBase;
-    private _baseTile;
+    private _prunePageState;
     private _resolveExcludeAndRange;
     private _excludeOrRangeDefault;
     private _countSortResets;

package/app/reports/tile-data-state.d.ts

@@ -1,7 +1,7 @@
-import { ReportViewConfig } from './interfaces/report-view-config.interface';
+import { ReportStateSnapshot } from './interfaces/report-state-snapshot.interface';
 import { ComponentDataState, Report, ReportComponent } from './interfaces/report.interface';
 export declare function isTimeSeriesChart(component: ReportComponent): boolean;
-export declare function tileDataState(report: Report | null, component: ReportComponent, snapshot: ReportViewConfig): ComponentDataState;
-export declare function zipExportStates(report: Report, snapshot: ReportViewConfig, pageId?: number | null): Record<number, ComponentDataState>;
-export declare function valuesMatchAnyGroupIds(report: Report | null, layerId: number | null, snapshot: ReportViewConfig): number[];
-export declare function tilePageId(report: Report, component: ReportComponent, snapshot: ReportViewConfig): number | null;
+export declare function tileDataState(report: Report | null, component: ReportComponent, snapshot: ReportStateSnapshot): ComponentDataState;
+export declare function zipExportStates(report: Report, snapshot: ReportStateSnapshot, pageId?: number | null): Record<number, ComponentDataState>;
+export declare function valuesMatchAnyGroupIds(report: Report | null, layerId: number | null, snapshot: ReportStateSnapshot): number[];
+export declare function tilePageId(report: Report, component: ReportComponent, snapshot: ReportStateSnapshot): number | null;

package/app/reports/views/report/fs-ai-report.component.d.ts

@@ -17,24 +17,25 @@ export declare class FsAiReportComponent {
     readonly reportFilterConfig: import("@angular/core").WritableSignal<FilterConfig>;
     readonly reportHasFilters: import("@angular/core").Signal<boolean>;
     readonly reportFilterKey: import("@angular/core").Signal<string>;
-    readonly viewsServed: import("@angular/core").Signal<boolean>;
     private _split;
     private _chatPanel;
     private _canvas?;
+    private _reportBar?;
     private _reportData;
     private _reportAiChatData;
     private _route;
+    private _router;
     private _filterState;
     private _filterOptions;
-    private _views;
     private _exportService;
     private _collector;
     private _process;
     private _dialog;
     private _destroyRef;
     private _zone;
-    private _openedReportId;
     private readonly _barVersion;
+    private _barValuesAtPick;
+    private _openedOnSavedFilterReportId;
     constructor();
     toggleEditMode(): void;
     get isMasterMode(): boolean;
@@ -51,12 +52,18 @@ export declare class FsAiReportComponent {
     onResizeStart(event: PointerEvent): void;
     private _chatViewerState;
     private _resizeTo;
+    private _writePageToUrl;
     private _pageIdFromUrl;
     private _loadReport;
-    private _openReport;
-    private _openAppliedPage;
     private _reportGroups;
     private _buildReportConfig;
+    private _openOnFirstSavedFilter;
+    private _savedFiltersConfig;
+    private _savedFilterGroups;
+    private _barSavedFilter;
+    private _keepBarOnPick;
+    private _keepOnPick;
+    private _keepItemOnPick;
     private _barChanged;
     private _groupByItem;
     private _matchItem;

package/esm2022/app/reports/canvas-landing-page.mjs

@@ -3,8 +3,8 @@
 // - The same report with more pages than before: a page was just added in
 //   this tab, so the canvas lands on the last page. The asked-for page does
 //   not beat it: that is a stale value the host still holds.
-// - Otherwise the asked-for page (a ?page= the report opened with, or the
-//   open view's), when the report has it.
+// - Otherwise the asked-for page (a ?page= the report opened with), when the
+//   report has it.
 // - Another report that asks for no page it has opens on its first page:
 //   the old report's page number means nothing there.
 // - The same report keeps the page it shows when the asked-for page does not
@@ -23,4 +23,4 @@ export function canvasLandingPage(input) {
     const index = sameReport ? input.activePageIndex : 0;
     return index < pageCount ? index : 0;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FudmFzLWxhbmRpbmctcGFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHAvcmVwb3J0cy9jYW52YXMtbGFuZGluZy1wYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLDZEQUE2RDtBQUM3RCxFQUFFO0FBQ0YsMEVBQTBFO0FBQzFFLDRFQUE0RTtBQUM1RSw2REFBNkQ7QUFDN0QsNkVBQTZFO0FBQzdFLG1CQUFtQjtBQUNuQix5RUFBeUU7QUFDekUsc0RBQXNEO0FBQ3RELDZFQUE2RTtBQUM3RSx5RUFBeUU7QUFDekUsdUJBQXVCO0FBQ3ZCLE1BQU0sVUFBVSxpQkFBaUIsQ0FBQyxLQUF5QjtJQUN6RCxNQUFNLFNBQVMsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQztJQUN2QyxNQUFNLFVBQVUsR0FBRyxLQUFLLENBQUMsUUFBUSxLQUFLLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQztJQUU3RCxJQUFJLFVBQVUsSUFBSSxLQUFLLENBQUMsaUJBQWlCLEdBQUcsQ0FBQyxJQUFJLFNBQVMsR0FBRyxLQUFLLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztRQUNyRixPQUFPLFNBQVMsR0FBRyxDQUFDLENBQUM7SUFDdkIsQ0FBQztJQUVELE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxNQUFNLElBQUksSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQy9FLElBQUksTUFBTSxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDaEIsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQztJQUVELE1BQU0sS0FBSyxHQUFHLFVBQVUsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLGVBQWUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXJELE9BQU8sS0FBSyxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDdkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENhbnZhc0xhbmRpbmdJbnB1dCB9IGZyb20gJy4vaW50ZXJmYWNlcy9jYW52YXMtbGFuZGluZy1pbnB1dC5pbnRlcmZhY2UnO1xuXG5cbi8vIFdoaWNoIHBhZ2UgdGhlIGNhbnZhcyBvcGVucyB3aGVuIGl0cyByZXBvcnQgaW5wdXQgY2hhbmdlcy5cbi8vXG4vLyAtIFRoZSBzYW1lIHJlcG9ydCB3aXRoIG1vcmUgcGFnZXMgdGhhbiBiZWZvcmU6IGEgcGFnZSB3YXMganVzdCBhZGRlZCBpblxuLy8gICB0aGlzIHRhYiwgc28gdGhlIGNhbnZhcyBsYW5kcyBvbiB0aGUgbGFzdCBwYWdlLiBUaGUgYXNrZWQtZm9yIHBhZ2UgZG9lc1xuLy8gICBub3QgYmVhdCBpdDogdGhhdCBpcyBhIHN0YWxlIHZhbHVlIHRoZSBob3N0IHN0aWxsIGhvbGRzLlxuLy8gLSBPdGhlcndpc2UgdGhlIGFza2VkLWZvciBwYWdlIChhID9wYWdlPSB0aGUgcmVwb3J0IG9wZW5lZCB3aXRoKSwgd2hlbiB0aGVcbi8vICAgcmVwb3J0IGhhcyBpdC5cbi8vIC0gQW5vdGhlciByZXBvcnQgdGhhdCBhc2tzIGZvciBubyBwYWdlIGl0IGhhcyBvcGVucyBvbiBpdHMgZmlyc3QgcGFnZTpcbi8vICAgdGhlIG9sZCByZXBvcnQncyBwYWdlIG51bWJlciBtZWFucyBub3RoaW5nIHRoZXJlLlxuLy8gLSBUaGUgc2FtZSByZXBvcnQga2VlcHMgdGhlIHBhZ2UgaXQgc2hvd3Mgd2hlbiB0aGUgYXNrZWQtZm9yIHBhZ2UgZG9lcyBub3Rcbi8vICAgcmVzb2x2ZSAoaXQgbWF5IHN0aWxsIGJlIGxvYWRpbmcpOyBhbiBpbmRleCBwYXN0IHRoZSBsYXN0IHBhZ2UgZmFsbHNcbi8vICAgYmFjayB0byB0aGUgZmlyc3QuXG5leHBvcnQgZnVuY3Rpb24gY2FudmFzTGFuZGluZ1BhZ2UoaW5wdXQ6IENhbnZhc0xhbmRpbmdJbnB1dCk6IG51bWJlciB7XG4gIGNvbnN0IHBhZ2VDb3VudCA9IGlucHV0LnBhZ2VJZHMubGVuZ3RoO1xuICBjb25zdCBzYW1lUmVwb3J0ID0gaW5wdXQucmVwb3J0SWQgPT09IGlucHV0LnByZXZpb3VzUmVwb3J0SWQ7XG5cbiAgaWYgKHNhbWVSZXBvcnQgJiYgaW5wdXQucHJldmlvdXNQYWdlQ291bnQgPiAwICYmIHBhZ2VDb3VudCA+IGlucHV0LnByZXZpb3VzUGFnZUNvdW50KSB7XG4gICAgcmV0dXJuIHBhZ2VDb3VudCAtIDE7XG4gIH1cblxuICBjb25zdCBsaW5rZWQgPSBpbnB1dC5wYWdlSWQgPT0gbnVsbCA/IC0xIDogaW5wdXQucGFnZUlkcy5pbmRleE9mKGlucHV0LnBhZ2VJZCk7XG4gIGlmIChsaW5rZWQgPiAtMSkge1xuICAgIHJldHVybiBsaW5rZWQ7XG4gIH1cblxuICBjb25zdCBpbmRleCA9IHNhbWVSZXBvcnQgPyBpbnB1dC5hY3RpdmVQYWdlSW5kZXggOiAwO1xuXG4gIHJldHVybiBpbmRleCA8IHBhZ2VDb3VudCA/IGluZGV4IDogMDtcbn1cbiJdfQ==

package/esm2022/app/reports/components/component-list/component-list.component.mjs

@@ -81,8 +81,8 @@ export class ComponentListComponent {
     // How many leading columns stay in view while the list scrolls sideways.
     pinned = computed(() => listPinnedColumns(this.component().config));
     columnClasses = columnClasses;
-    // The config columns the viewer hid on this list (the Columns dialog, or a
-    // saved view). fs-list hides and shows them in place through [show], so the rows
+    // The config columns the viewer hid on this list (the Columns dialog). fs-list
+    // hides and shows them in place through [show], so the rows
     // already fetched stand.
     hidden = computed(() => new Set(this._filterState.hiddenColumns(this.component().id)));
     totalLabel = LIST_TOTAL_LABEL;
@@ -348,4 +348,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                         ReportOutputPipe,
                     ], template: "@if (truncated()) {\n  <div class=\"pivot-truncated\">\n    This grid was built from a partial result, so some columns or values may be missing. Narrow it with a filter.\n  </div>\n}\n\n<!-- The windows a comparison compares, and why it reads as it does. A\n     windowed column's own notes are in its header's tooltip. -->\n<app-report-component-note\n  [data]=\"noteData()\"\n  [windowNotes]=\"false\">\n</app-report-component-note>\n\n<!-- fs-list reads a column's footer template once, as a direct child of\n     fs-list-column, so a list with totals renders its columns in a branch of\n     their own rather than wrapping the footer in an @if. Its header template too,\n     which every column carries: an output column's tooltip says what it holds.\n     Columns are tracked by alignment as well as name, since fs-list reads a\n     column's alignment only when it builds the column. -->\n<fs-list\n  [config]=\"listConfig\"\n  [class.report-totals-empty]=\"!totals()\">\n  @if (showTotals()) {\n    @for (column of columns(); track column.column + ':' + column.numeric) {\n      <fs-list-column\n        [name]=\"column.column\"\n        [title]=\"column.label || column.column\"\n        [show]=\"!hidden().has(column.column)\"\n        [sortable]=\"!pivoted() || $first\"\n        [align]=\"column.numeric ? 'right' : 'left'\"\n        [class]=\"columnClasses(column, $index, pinned())\">\n        <ng-template fs-list-header>\n          <ng-container\n            [ngTemplateOutlet]=\"headerTpl\"\n            [ngTemplateOutletContext]=\"{ column: column }\">\n          </ng-container>\n        </ng-template>\n        <ng-template\n          fs-list-cell\n          let-row=\"row\">\n          <ng-container\n            [ngTemplateOutlet]=\"cellTpl\"\n            [ngTemplateOutletContext]=\"{ $implicit: row[column.column], row: row, column: column }\">\n          </ng-container>\n        </ng-template>\n        <ng-template fs-list-footer>\n          @if (totals()?.[column.column] !== undefined) {\n            <ng-container\n              [ngTemplateOutlet]=\"cellTpl\"\n              [ngTemplateOutletContext]=\"{ $implicit: totals()?.[column.column], row: totals(), column: column }\">\n            </ng-container>\n          } @else if (column.column === totalsLabelColumn()) {\n            {{ totalLabel }}\n          }\n        </ng-template>\n      </fs-list-column>\n    }\n  } @else {\n    @for (column of columns(); track column.column + ':' + column.numeric) {\n      <fs-list-column\n        [name]=\"column.column\"\n        [title]=\"column.label || column.column\"\n        [show]=\"!hidden().has(column.column)\"\n        [sortable]=\"!pivoted() || $first\"\n        [align]=\"column.numeric ? 'right' : 'left'\"\n        [class]=\"columnClasses(column, $index, pinned())\">\n        <ng-template fs-list-header>\n          <ng-container\n            [ngTemplateOutlet]=\"headerTpl\"\n            [ngTemplateOutletContext]=\"{ column: column }\">\n          </ng-container>\n        </ng-template>\n        <ng-template\n          fs-list-cell\n          let-row=\"row\">\n          <ng-container\n            [ngTemplateOutlet]=\"cellTpl\"\n            [ngTemplateOutletContext]=\"{ $implicit: row[column.column], row: row, column: column }\">\n          </ng-container>\n        </ng-template>\n      </fs-list-column>\n    }\n  }\n</fs-list>\n\n@if (caption()) {\n  <div class=\"list-caption small\">\n    {{ caption() }}\n  </div>\n}\n\n<!-- A column's heading, with what an output column holds as its tooltip (an\n     empty one never shows). -->\n<ng-template\n  #headerTpl\n  let-column=\"column\">\n  <span [matTooltip]=\"columnNotes()[column.column] ?? ''\">{{ column.label || column.column }}</span>\n</ng-template>\n\n<!-- One cell, in the body and the totals row alike: an output column by what\n     it holds (its row gives a change its prior), a date column as a day in the\n     report's zone and locale, any other through its number format. -->\n<ng-template\n  #cellTpl\n  let-value\n  let-row=\"row\"\n  let-column=\"column\">\n  @if (outputColumns()[column.column]; as output) {\n    @if (row | fsReportOutput: column : output : formatContext(); as cell) {\n      <span [attr.title]=\"cell.title\">{{ cell.text }}</span>\n    }\n  } @else if (column.format === ReportListColumnFormat.Date) {\n    {{ value | fsReportDate: timezone() : formatContext().locale }}\n  } @else {\n    {{ value | fsReportNumber: column : formatContext() }}\n  }\n</ng-template>\n", styles: [":host{display:flex;flex-direction:column;width:100%;height:100%;min-height:0}:host ::ng-deep fs-list{display:flex;flex-direction:column;flex:1 1 auto;height:auto;min-height:0}:host ::ng-deep fs-list .fs-list-container{display:flex;flex-direction:column;flex:1 1 auto;min-height:0;height:100%}:host ::ng-deep fs-list .fs-list-header-container{flex:0 0 auto}:host ::ng-deep fs-list .fs-list-container .fs-list-table-container{flex:1 1 auto;min-height:0;overflow-y:auto!important}:host ::ng-deep fs-list .fs-list-table thead th{position:sticky;top:0;z-index:1;background-color:#fff}:host ::ng-deep fs-list .fs-list-table tfoot td{position:sticky;bottom:0;z-index:1;background-color:#fff;font-weight:500;box-shadow:inset 0 1px #0000001f}:host ::ng-deep fs-list.report-totals-empty tfoot{display:none}:host ::ng-deep fs-list .report-pinned{position:sticky;left:var(--report-pin-left, 0px);z-index:1;background-color:#fff}:host ::ng-deep fs-list .report-pin-0{--report-pin-left: var(--report-pin-left-0, 0px)}:host ::ng-deep fs-list .report-pin-1{--report-pin-left: var(--report-pin-left-1, 0px)}:host ::ng-deep fs-list .report-pin-2{--report-pin-left: var(--report-pin-left-2, 0px)}:host ::ng-deep fs-list .report-pin-last{box-shadow:inset -1px 0 #0000001f}:host ::ng-deep fs-list .fs-list-table thead th.report-pinned{z-index:3}:host ::ng-deep fs-list .fs-list-table tfoot td.report-pinned{z-index:2}:host ::ng-deep fs-list .fs-list-table tfoot td.report-pin-last{box-shadow:inset -1px 0 #0000001f,inset 0 1px #0000001f}:host ::ng-deep fs-list th.report-nowrap,:host ::ng-deep fs-list td.report-nowrap{white-space:nowrap}:host ::ng-deep fs-list fs-list-pagination{flex:0 0 auto}:host ::ng-deep fs-list .fs-list-load-more{position:sticky;bottom:0;background-color:#fff}:host ::ng-deep fs-list .fs-list-load-more button{margin-top:0}.list-caption{flex:0 0 auto;padding-top:4px}.pivot-truncated{flex:0 0 auto;padding:8px 12px;margin-bottom:8px;border-radius:4px;background-color:#fff4e5;color:#663c00}\n"] }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-list.component.js","sourceRoot":"","sources":["../../../../../../src/app/reports/components/component-list/component-list.component.ts","../../../../../../src/app/reports/components/component-list/component-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n  AfterRenderRef,\n  ChangeDetectionStrategy,\n  Component,\n  DestroyRef,\n  ElementRef,\n  Injector,\n  OnInit,\n  afterNextRender,\n  computed,\n  effect,\n  inject,\n  input,\n  signal,\n  untracked,\n  viewChild,\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { MatTooltip } from '@angular/material/tooltip';\n\nimport { FsListComponent, FsListConfig, FsListModule, PaginationStrategy } from '@firestitch/list';\n\nimport { Observable, map, merge, tap } from 'rxjs';\n\nimport { ReportData } from '../../data/report.data';\nimport { ReportListColumnFormat } from '../../enums/report-list-column-format.enum';\nimport { formatPlainNumber, hasNumberFormat } from '../../format';\nimport {\n  ComponentData,\n  ComponentDataState,\n  ListColumn,\n  ListConfig,\n  ReportComponent,\n  ReportSort,\n} from '../../interfaces/report.interface';\nimport {\n  LIST_TOTAL_LABEL,\n  ListOutputColumn,\n  columnClasses,\n  listOutputColumns,\n  listPinnedColumns,\n  listSortTerms,\n  listTotalsLabelColumn,\n} from '../../list-config';\nimport { pivotColumnSpecs } from '../../option-builder';\nimport { ComponentNoteData, outputColumnNote } from '../../output-notes';\nimport { ReportDatePipe } from '../../pipes/report-date.pipe';\nimport { ReportNumberPipe } from '../../pipes/report-number.pipe';\nimport { ReportOutputPipe } from '../../pipes/report-output.pipe';\nimport { ReportFilterStateService } from '../../services/report-filter-state.service';\nimport { ComponentNoteComponent } from '../component-note/component-note.component';\n\n\n// A list component: an FsList rendered from the component's config. It has no\n// filter bar of its own: its filters are group-keyed like every other\n// component's, so component-level groups render in the component header strip\n// (ReportComponentComponent) and report-level groups in the report bar, and\n// every request takes its values from the shared filter-state service.\n// Paging and sorting are pushed into the SQL wrap server-side.\n//\n// A list whose query compares, windows, ranks or shares says so: the shared\n// note above it names the windows a comparison compares, each such column's\n// header tooltip says what it holds, and its cells (totals included, which the\n// server computes) are written by what they hold.\n@Component({\n  selector: 'app-report-component-list',\n  templateUrl: './component-list.component.html',\n  styleUrls: ['./component-list.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    ComponentNoteComponent,\n    FsListModule,\n    MatTooltip,\n    NgTemplateOutlet,\n    ReportDatePipe,\n    ReportNumberPipe,\n    ReportOutputPipe,\n  ],\n})\nexport class ComponentListComponent implements OnInit {\n\n  public readonly reportId = input.required<number>();\n  public readonly component = input.required<ReportComponent>();\n\n  public readonly listComponent = viewChild(FsListComponent);\n\n  public listConfig: FsListConfig;\n\n  // A plain list's columns are authored and fixed at init. A cross-tab's are\n  // the pivot dimension's VALUES, so they arrive with the rows and change\n  // whenever the filters do — which is why this is a signal rather than the\n  // one-shot read it used to be. `numeric` marks a column whose cells are\n  // formatted numbers, decided once here rather than per cell, so the column\n  // and its header are right-aligned.\n  public columns = signal<(ListColumn & { numeric: boolean })[]>([]);\n\n  // A cross-tab sorts only by its row-key column: every other header is a\n  // pivot value, and the server orders the long rows before pivoting, so a\n  // click on \"Mar 2026\" has nothing to order by.\n  public pivoted = signal(false);\n\n  // A cut result is worse for a grid than for a list: the cut lands on the LONG\n  // rows before the reshape, so a pivot value living only in the tail vanishes\n  // as a whole COLUMN and straddled cells come back blank, indistinguishable\n  // from a real zero. The parent's truncation banner never fires for a list\n  // (it only renders what _load() fetched, which lists skip), so the warning\n  // belongs here.\n  public truncated = signal(false);\n\n  // Why the search box did not narrow the rows (the list has no text column to\n  // search), from the latest page 1; null when the search applied or none was\n  // made.\n  public readonly searchNote = signal<string | null>(null);\n\n  // config.totals, read once at init: a list with totals renders its columns\n  // with a footer template, which fs-list reads only when it builds them.\n  public readonly showTotals = signal(false);\n\n  // The totals row from the latest page 1, raw values keyed like the columns;\n  // null when the list has none, or the server says why in totalsNote.\n  public readonly totals = signal<Record<string, unknown> | null>(null);\n\n  public readonly totalsNote = signal<string | null>(null);\n\n  // The latest page 1's comparison windows, timeframe and output metadata, for\n  // the note above the list, the header tooltips and the output cells; null\n  // until it arrives, and empty of every key for a list that has none.\n  public readonly noteData = signal<ComponentNoteData | null>(null);\n\n  // How many rows the list shows (load more appends) out of how many its\n  // filters keep. A cross-tab counts grid rows.\n  public readonly rowCount = signal<{ shown: number; total: number } | null>(null);\n\n  // The report's effective zone, which date cells render in. Injected right\n  // here rather than read off _filterState, which is declared further down and\n  // is still undefined while this initializer runs.\n  public readonly timezone = inject(ReportFilterStateService).timezone;\n\n  // The open report's format context: date cells, number cells and a\n  // cross-tab's period headings are written in its locale (and money in its\n  // currency). Injected here for the same reason.\n  public readonly formatContext = inject(ReportFilterStateService).formatContext;\n\n  public readonly ReportListColumnFormat = ReportListColumnFormat;\n\n  // How many leading columns stay in view while the list scrolls sideways.\n  public readonly pinned = computed(() => listPinnedColumns(this.component().config));\n\n  public readonly columnClasses = columnClasses;\n\n  // The config columns the viewer hid on this list (the Columns dialog, or a\n  // saved view). fs-list hides and shows them in place through [show], so the rows\n  // already fetched stand.\n  public readonly hidden = computed(() => new Set(this._filterState.hiddenColumns(this.component().id)));\n\n  public readonly totalLabel = LIST_TOTAL_LABEL;\n\n  // The columns that hold a compared, windowed, ranked or shared output, by\n  // name; the rest are written as before.\n  public readonly outputColumns = computed<Record<string, ListOutputColumn>>(() => listOutputColumns(\n    this.columns(),\n    this.noteData(),\n    ((this.component().config ?? {}) as ListConfig).columns ?? [],\n  ));\n\n  // Each column's header tooltip: what an output column holds ('' for any\n  // other).\n  public readonly columnNotes = computed<Record<string, string>>(() => {\n    const locale = this.formatContext().locale;\n\n    return Object.fromEntries(this.columns()\n      .map((column) => [column.column, outputColumnNote(column.column, this.noteData(), locale)]));\n  });\n\n  // The column whose footer cell reads 'Total': the first one shown, unless\n  // it holds a total itself.\n  public readonly totalsLabelColumn = computed(() => listTotalsLabelColumn(\n    this.columns().filter((column) => !this.hidden().has(column.column)),\n    this.totals(),\n  ));\n\n  // The line under the list: its row count, then why it has no totals and why\n  // its search narrowed nothing. The digits are written in the report's\n  // locale, never the app's.\n  public readonly caption = computed(() => {\n    const count = this.rowCount();\n    const locale = this.formatContext().locale;\n    const parts: string[] = [];\n\n    if (count) {\n      const total = formatPlainNumber(count.total, locale);\n      parts.push(count.shown < count.total\n        ? `Showing ${formatPlainNumber(count.shown, locale)} of ${total}`\n        : `${total} row(s)`);\n    }\n\n    return [...parts, this.totalsNote(), this.searchNote()]\n      .filter((part): part is string => !!part)\n      .join(' · ');\n  });\n\n  private _reportData = inject(ReportData);\n  private _filterState = inject(ReportFilterStateService);\n  private _destroyRef = inject(DestroyRef);\n  private _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  private _injector = inject(Injector);\n  private _pinOffsetsRef: AfterRenderRef | null = null;\n\n  constructor() {\n    // Hiding or showing a column moves the pinned columns after it.\n    effect(() => {\n      this.hidden();\n      untracked(() => this._schedulePinOffsets());\n    });\n  }\n\n  public ngOnInit(): void {\n    const component = this.component();\n    const config = (component.config ?? {}) as ListConfig;\n    this.pivoted.set(!!config.pivotBy?.column);\n    this.showTotals.set(config.totals === true);\n    this.columns.set((config.columns ?? []).map((column) => ({ ...column, numeric: hasNumberFormat(column) })));\n\n    this._initListConfig(config);\n    this._observePinOffsets();\n\n    // A change to any group this list's filters belong to (from the report bar\n    // or the component header strip) re-runs the list.\n    // So does a change of the text in its search box (in the component header).\n    merge(this._filterState.changesFor(component), this._filterState.listSearchChanges(component.id))\n      .pipe(\n        tap(() => this.listComponent()?.reload()),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe();\n  }\n\n  private _initListConfig(config: ListConfig): void {\n    // The viewer's last sort wins over the authored one, so a list recreated\n    // in the same session (page switch, reload after an edit) keeps it.\n    // fs-list holds one sorting column, so it shows the authored sort's first\n    // term; the request sends only that term and the server appends the rest.\n    const sort: ReportSort | undefined = this._filterState.listSort(this.component().id)\n      ?? listSortTerms(config)[0];\n\n    this.listConfig = {\n      // Inside a report component the list is a clean data pane — no status\n      // bar, no reload button (filter changes already refetch).\n      status: false,\n      reload: false,\n      // FsList never touches the URL or persists sort/paging state. The sort\n      // is kept in ReportFilterStateService (setListSort), and paging stays\n      // out of it.\n      queryParam: false,\n      persist: false,\n      sort: sort\n        ? { value: sort.column, direction: sort.direction ?? 'asc' }\n        : undefined,\n      // Load-more: the list keeps a fixed, scrollable height and appends the\n      // next page in place instead of swapping pages. The button is pinned to\n      // the bottom of the scroll pane (see component SCSS).\n      //\n      // Uses the Offset strategy (offset + limit) rather than Many: in\n      // @firestitch/list the pagination template resolves `hasManyStrategy`\n      // BEFORE `loadMoreEnabled`, and Many renders a forward-only page pager —\n      // so Many would suppress the load-more button entirely. Offset + loadMore\n      // is the combination that actually renders and appends. `_fetch` already\n      // derives `page` from `offset`, so the server-side wrap is unaffected.\n      paging: {\n        limit: config.pageSize ?? 25,\n        strategy: PaginationStrategy.Offset,\n      },\n      loadMore: {\n        enabled: true,\n        label: 'Load more',\n        buttonType: 'stroked',\n      },\n      fetch: (query: any) => this._fetch(query),\n    };\n  }\n\n  private _fetch(query: any): Observable<{ data: Record<string, unknown>[]; paging: any }> {\n    // Many/load-more sends `offset` + `limit` (not `page`); derive the page so\n    // the server-side wrap keeps working unchanged. Page strategy still sends\n    // `page` directly.\n    const pageSize = query.limit ?? 25;\n    const page = query.page\n      ?? (query.offset != null ? Math.floor(query.offset / pageSize) + 1 : 1);\n\n    const state: ComponentDataState = {\n      page,\n      pageSize,\n    };\n\n    const order = String(query.order ?? '');\n    if (order) {\n      const [column, direction] = order.split(',');\n      state.sort = { column, direction: direction === 'desc' ? 'desc' : 'asc' };\n    }\n\n    const component = this.component();\n    this._filterState.setListSort(component, state.sort ?? null);\n\n    const search = this._filterState.listSearch(component.id);\n    if (search) {\n      state.search = search;\n    }\n\n    // The groups that match 'any', as every other read of this tile sends\n    // them (tileDataState). The sort and paging above are FsList's own.\n    const { matchAnyGroupIds } = this._filterState.tileState(component);\n    if (matchAnyGroupIds) {\n      state.matchAnyGroupIds = matchAnyGroupIds;\n    }\n\n    // One source for filter values, the same one charts, KPIs and the exports\n    // read, so the list is filtered exactly as its header strip shows.\n    const filters = this._filterState.resolveForComponent(component);\n\n    return this._reportData\n      .componentData(this.reportId(), component.id, filters, state)\n      .pipe(\n        map((data: ComponentData) => {\n          // A cross-tab's headers come back with the rows: the row-key column\n          // first, then one per pivot value. Re-read them on every fetch, since\n          // a filter change can add or remove a column.\n          if (this.pivoted()) {\n            this.columns.set(this._pivotColumns(data));\n            this.truncated.set(!!data.truncated);\n          }\n\n          // Only page 1 carries the notes and the totals; a load-more page\n          // leaves them as they are.\n          if (state.page === 1) {\n            this.searchNote.set(data.searchNote ?? null);\n            this.totals.set(data.totals ?? null);\n            this.totalsNote.set(data.totalsNote ?? null);\n            this.noteData.set(this._noteData(data));\n            this._alignOutputColumns(data);\n          }\n\n          // The server's page size when it sends one (it clamps the request),\n          // the size the paging below hands fs-list too.\n          const size = data.paging?.pageSize ?? state.pageSize;\n          const shown = (state.page - 1) * size + (data.rows?.length ?? 0);\n          this.rowCount.set({ shown, total: data.paging?.total ?? shown });\n\n          // New rows can widen a pinned column, which moves the ones after it.\n          this._schedulePinOffsets();\n\n          return {\n            data: data.rows ?? [],\n            paging: {\n              limit: data.paging?.pageSize ?? state.pageSize,\n              records: data.paging?.total ?? (data.rows?.length ?? 0),\n              page: data.paging?.page ?? state.page,\n            },\n          };\n        }),\n      );\n  }\n\n  // A cross-tab's columns, built from the wire by pivotColumnSpecs(): the same\n  // headings and cell format the PDF and PowerPoint exports use. A cell column\n  // whose measure is a rank or a share (cellMeasures names it) holds numbers\n  // whether or not the grid names a cell format.\n  private _pivotColumns(data: ComponentData): (ListColumn & { numeric: boolean })[] {\n    const config = (this.component().config ?? {}) as ListConfig;\n    const outputCells = Object.keys(listOutputColumns(\n      (data.columns ?? []).slice(1).map((column) => ({ column })),\n      data,\n      [],\n    ));\n\n    return pivotColumnSpecs(config, data, this.formatContext().locale)\n      .map((column) => ({ ...column, numeric: column.numeric || outputCells.includes(column.column) }));\n  }\n\n  private _noteData(data: ComponentData): ComponentNoteData {\n    return {\n      comparison: data.comparison,\n      timeframe: data.timeframe,\n      outputs: data.outputs,\n      cellMeasures: data.cellMeasures,\n      windows: data.windows,\n      granularity: data.granularity,\n    };\n  }\n\n  // A plain list's columns are built before any data arrives, so an output\n  // column that names no format of its own (a rank, a share, a prior that takes\n  // its measure's format) learns it holds numbers from page 1. fs-list reads a\n  // column's alignment only when it builds the column, so a column whose\n  // alignment changes is rebuilt (the template tracks columns by both).\n  private _alignOutputColumns(data: ComponentData): void {\n    if (this.pivoted() || !data.outputs) {\n      return;\n    }\n\n    const columns = this.columns();\n    const aligned = columns.map((column) => ({\n      ...column,\n      numeric: hasNumberFormat(column) || !!data.outputs[column.column],\n    }));\n\n    if (aligned.some((column, index) => column.numeric !== columns[index].numeric)) {\n      this.columns.set(aligned);\n    }\n  }\n\n  // A tile resize reflows the table's auto layout, so the pinned columns'\n  // widths, and with them their offsets, change.\n  private _observePinOffsets(): void {\n    if (this.pinned() < 2 || typeof ResizeObserver === 'undefined') {\n      return;\n    }\n\n    const observer = new ResizeObserver(() => this._schedulePinOffsets());\n    observer.observe(this._elementRef.nativeElement);\n    this._destroyRef.onDestroy(() => observer.disconnect());\n  }\n\n  // Measures the pinned offsets once the next render has laid the table out.\n  // One pending measurement covers every request made before it runs. Only\n  // afterNextRender exists in every Angular version this library runs on.\n  private _schedulePinOffsets(): void {\n    if (this.pinned() < 2 || this._pinOffsetsRef) {\n      return;\n    }\n\n    this._pinOffsetsRef = afterNextRender(() => {\n      this._pinOffsetsRef = null;\n      this._updatePinOffsets();\n    }, { injector: this._injector });\n  }\n\n  // Each pinned column sticks at the summed width of the visible pinned\n  // columns before it. A hidden column renders no header, so the next pinned\n  // one takes its place. A variable is written only when its value changed,\n  // which keeps a resize from restyling the table for nothing.\n  private _updatePinOffsets(): void {\n    const host = this._elementRef.nativeElement;\n    let left = 0;\n\n    for (let index = 0; index < this.pinned(); index++) {\n      const header = host.querySelector<HTMLElement>(`thead th.report-pin-${index}`);\n\n      if (!header) {\n        continue;\n      }\n\n      const name = `--report-pin-left-${index}`;\n      const value = `${Math.round(left * 100) / 100}px`;\n\n      if (host.style.getPropertyValue(name) !== value) {\n        host.style.setProperty(name, value);\n      }\n\n      left += header.getBoundingClientRect().width;\n    }\n  }\n}\n","@if (truncated()) {\n  <div class=\"pivot-truncated\">\n    This grid was built from a partial result, so some columns or values may be missing. Narrow it with a filter.\n  </div>\n}\n\n<!-- The windows a comparison compares, and why it reads as it does. A\n     windowed column's own notes are in its header's tooltip. -->\n<app-report-component-note\n  [data]=\"noteData()\"\n  [windowNotes]=\"false\">\n</app-report-component-note>\n\n<!-- fs-list reads a column's footer template once, as a direct child of\n     fs-list-column, so a list with totals renders its columns in a branch of\n     their own rather than wrapping the footer in an @if. Its header template too,\n     which every column carries: an output column's tooltip says what it holds.\n     Columns are tracked by alignment as well as name, since fs-list reads a\n     column's alignment only when it builds the column. -->\n<fs-list\n  [config]=\"listConfig\"\n  [class.report-totals-empty]=\"!totals()\">\n  @if (showTotals()) {\n    @for (column of columns(); track column.column + ':' + column.numeric) {\n      <fs-list-column\n        [name]=\"column.column\"\n        [title]=\"column.label || column.column\"\n        [show]=\"!hidden().has(column.column)\"\n        [sortable]=\"!pivoted() || $first\"\n        [align]=\"column.numeric ? 'right' : 'left'\"\n        [class]=\"columnClasses(column, $index, pinned())\">\n        <ng-template fs-list-header>\n          <ng-container\n            [ngTemplateOutlet]=\"headerTpl\"\n            [ngTemplateOutletContext]=\"{ column: column }\">\n          </ng-container>\n        </ng-template>\n        <ng-template\n          fs-list-cell\n          let-row=\"row\">\n          <ng-container\n            [ngTemplateOutlet]=\"cellTpl\"\n            [ngTemplateOutletContext]=\"{ $implicit: row[column.column], row: row, column: column }\">\n          </ng-container>\n        </ng-template>\n        <ng-template fs-list-footer>\n          @if (totals()?.[column.column] !== undefined) {\n            <ng-container\n              [ngTemplateOutlet]=\"cellTpl\"\n              [ngTemplateOutletContext]=\"{ $implicit: totals()?.[column.column], row: totals(), column: column }\">\n            </ng-container>\n          } @else if (column.column === totalsLabelColumn()) {\n            {{ totalLabel }}\n          }\n        </ng-template>\n      </fs-list-column>\n    }\n  } @else {\n    @for (column of columns(); track column.column + ':' + column.numeric) {\n      <fs-list-column\n        [name]=\"column.column\"\n        [title]=\"column.label || column.column\"\n        [show]=\"!hidden().has(column.column)\"\n        [sortable]=\"!pivoted() || $first\"\n        [align]=\"column.numeric ? 'right' : 'left'\"\n        [class]=\"columnClasses(column, $index, pinned())\">\n        <ng-template fs-list-header>\n          <ng-container\n            [ngTemplateOutlet]=\"headerTpl\"\n            [ngTemplateOutletContext]=\"{ column: column }\">\n          </ng-container>\n        </ng-template>\n        <ng-template\n          fs-list-cell\n          let-row=\"row\">\n          <ng-container\n            [ngTemplateOutlet]=\"cellTpl\"\n            [ngTemplateOutletContext]=\"{ $implicit: row[column.column], row: row, column: column }\">\n          </ng-container>\n        </ng-template>\n      </fs-list-column>\n    }\n  }\n</fs-list>\n\n@if (caption()) {\n  <div class=\"list-caption small\">\n    {{ caption() }}\n  </div>\n}\n\n<!-- A column's heading, with what an output column holds as its tooltip (an\n     empty one never shows). -->\n<ng-template\n  #headerTpl\n  let-column=\"column\">\n  <span [matTooltip]=\"columnNotes()[column.column] ?? ''\">{{ column.label || column.column }}</span>\n</ng-template>\n\n<!-- One cell, in the body and the totals row alike: an output column by what\n     it holds (its row gives a change its prior), a date column as a day in the\n     report's zone and locale, any other through its number format. -->\n<ng-template\n  #cellTpl\n  let-value\n  let-row=\"row\"\n  let-column=\"column\">\n  @if (outputColumns()[column.column]; as output) {\n    @if (row | fsReportOutput: column : output : formatContext(); as cell) {\n      <span [attr.title]=\"cell.title\">{{ cell.text }}</span>\n    }\n  } @else if (column.format === ReportListColumnFormat.Date) {\n    {{ value | fsReportDate: timezone() : formatContext().locale }}\n  } @else {\n    {{ value | fsReportNumber: column : formatContext() }}\n  }\n</ng-template>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-list.component.js","sourceRoot":"","sources":["../../../../../../src/app/reports/components/component-list/component-list.component.ts","../../../../../../src/app/reports/components/component-list/component-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n  AfterRenderRef,\n  ChangeDetectionStrategy,\n  Component,\n  DestroyRef,\n  ElementRef,\n  Injector,\n  OnInit,\n  afterNextRender,\n  computed,\n  effect,\n  inject,\n  input,\n  signal,\n  untracked,\n  viewChild,\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { MatTooltip } from '@angular/material/tooltip';\n\nimport { FsListComponent, FsListConfig, FsListModule, PaginationStrategy } from '@firestitch/list';\n\nimport { Observable, map, merge, tap } from 'rxjs';\n\nimport { ReportData } from '../../data/report.data';\nimport { ReportListColumnFormat } from '../../enums/report-list-column-format.enum';\nimport { formatPlainNumber, hasNumberFormat } from '../../format';\nimport {\n  ComponentData,\n  ComponentDataState,\n  ListColumn,\n  ListConfig,\n  ReportComponent,\n  ReportSort,\n} from '../../interfaces/report.interface';\nimport {\n  LIST_TOTAL_LABEL,\n  ListOutputColumn,\n  columnClasses,\n  listOutputColumns,\n  listPinnedColumns,\n  listSortTerms,\n  listTotalsLabelColumn,\n} from '../../list-config';\nimport { pivotColumnSpecs } from '../../option-builder';\nimport { ComponentNoteData, outputColumnNote } from '../../output-notes';\nimport { ReportDatePipe } from '../../pipes/report-date.pipe';\nimport { ReportNumberPipe } from '../../pipes/report-number.pipe';\nimport { ReportOutputPipe } from '../../pipes/report-output.pipe';\nimport { ReportFilterStateService } from '../../services/report-filter-state.service';\nimport { ComponentNoteComponent } from '../component-note/component-note.component';\n\n\n// A list component: an FsList rendered from the component's config. It has no\n// filter bar of its own: its filters are group-keyed like every other\n// component's, so component-level groups render in the component header strip\n// (ReportComponentComponent) and report-level groups in the report bar, and\n// every request takes its values from the shared filter-state service.\n// Paging and sorting are pushed into the SQL wrap server-side.\n//\n// A list whose query compares, windows, ranks or shares says so: the shared\n// note above it names the windows a comparison compares, each such column's\n// header tooltip says what it holds, and its cells (totals included, which the\n// server computes) are written by what they hold.\n@Component({\n  selector: 'app-report-component-list',\n  templateUrl: './component-list.component.html',\n  styleUrls: ['./component-list.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    ComponentNoteComponent,\n    FsListModule,\n    MatTooltip,\n    NgTemplateOutlet,\n    ReportDatePipe,\n    ReportNumberPipe,\n    ReportOutputPipe,\n  ],\n})\nexport class ComponentListComponent implements OnInit {\n\n  public readonly reportId = input.required<number>();\n  public readonly component = input.required<ReportComponent>();\n\n  public readonly listComponent = viewChild(FsListComponent);\n\n  public listConfig: FsListConfig;\n\n  // A plain list's columns are authored and fixed at init. A cross-tab's are\n  // the pivot dimension's VALUES, so they arrive with the rows and change\n  // whenever the filters do — which is why this is a signal rather than the\n  // one-shot read it used to be. `numeric` marks a column whose cells are\n  // formatted numbers, decided once here rather than per cell, so the column\n  // and its header are right-aligned.\n  public columns = signal<(ListColumn & { numeric: boolean })[]>([]);\n\n  // A cross-tab sorts only by its row-key column: every other header is a\n  // pivot value, and the server orders the long rows before pivoting, so a\n  // click on \"Mar 2026\" has nothing to order by.\n  public pivoted = signal(false);\n\n  // A cut result is worse for a grid than for a list: the cut lands on the LONG\n  // rows before the reshape, so a pivot value living only in the tail vanishes\n  // as a whole COLUMN and straddled cells come back blank, indistinguishable\n  // from a real zero. The parent's truncation banner never fires for a list\n  // (it only renders what _load() fetched, which lists skip), so the warning\n  // belongs here.\n  public truncated = signal(false);\n\n  // Why the search box did not narrow the rows (the list has no text column to\n  // search), from the latest page 1; null when the search applied or none was\n  // made.\n  public readonly searchNote = signal<string | null>(null);\n\n  // config.totals, read once at init: a list with totals renders its columns\n  // with a footer template, which fs-list reads only when it builds them.\n  public readonly showTotals = signal(false);\n\n  // The totals row from the latest page 1, raw values keyed like the columns;\n  // null when the list has none, or the server says why in totalsNote.\n  public readonly totals = signal<Record<string, unknown> | null>(null);\n\n  public readonly totalsNote = signal<string | null>(null);\n\n  // The latest page 1's comparison windows, timeframe and output metadata, for\n  // the note above the list, the header tooltips and the output cells; null\n  // until it arrives, and empty of every key for a list that has none.\n  public readonly noteData = signal<ComponentNoteData | null>(null);\n\n  // How many rows the list shows (load more appends) out of how many its\n  // filters keep. A cross-tab counts grid rows.\n  public readonly rowCount = signal<{ shown: number; total: number } | null>(null);\n\n  // The report's effective zone, which date cells render in. Injected right\n  // here rather than read off _filterState, which is declared further down and\n  // is still undefined while this initializer runs.\n  public readonly timezone = inject(ReportFilterStateService).timezone;\n\n  // The open report's format context: date cells, number cells and a\n  // cross-tab's period headings are written in its locale (and money in its\n  // currency). Injected here for the same reason.\n  public readonly formatContext = inject(ReportFilterStateService).formatContext;\n\n  public readonly ReportListColumnFormat = ReportListColumnFormat;\n\n  // How many leading columns stay in view while the list scrolls sideways.\n  public readonly pinned = computed(() => listPinnedColumns(this.component().config));\n\n  public readonly columnClasses = columnClasses;\n\n  // The config columns the viewer hid on this list (the Columns dialog). fs-list\n  // hides and shows them in place through [show], so the rows\n  // already fetched stand.\n  public readonly hidden = computed(() => new Set(this._filterState.hiddenColumns(this.component().id)));\n\n  public readonly totalLabel = LIST_TOTAL_LABEL;\n\n  // The columns that hold a compared, windowed, ranked or shared output, by\n  // name; the rest are written as before.\n  public readonly outputColumns = computed<Record<string, ListOutputColumn>>(() => listOutputColumns(\n    this.columns(),\n    this.noteData(),\n    ((this.component().config ?? {}) as ListConfig).columns ?? [],\n  ));\n\n  // Each column's header tooltip: what an output column holds ('' for any\n  // other).\n  public readonly columnNotes = computed<Record<string, string>>(() => {\n    const locale = this.formatContext().locale;\n\n    return Object.fromEntries(this.columns()\n      .map((column) => [column.column, outputColumnNote(column.column, this.noteData(), locale)]));\n  });\n\n  // The column whose footer cell reads 'Total': the first one shown, unless\n  // it holds a total itself.\n  public readonly totalsLabelColumn = computed(() => listTotalsLabelColumn(\n    this.columns().filter((column) => !this.hidden().has(column.column)),\n    this.totals(),\n  ));\n\n  // The line under the list: its row count, then why it has no totals and why\n  // its search narrowed nothing. The digits are written in the report's\n  // locale, never the app's.\n  public readonly caption = computed(() => {\n    const count = this.rowCount();\n    const locale = this.formatContext().locale;\n    const parts: string[] = [];\n\n    if (count) {\n      const total = formatPlainNumber(count.total, locale);\n      parts.push(count.shown < count.total\n        ? `Showing ${formatPlainNumber(count.shown, locale)} of ${total}`\n        : `${total} row(s)`);\n    }\n\n    return [...parts, this.totalsNote(), this.searchNote()]\n      .filter((part): part is string => !!part)\n      .join(' · ');\n  });\n\n  private _reportData = inject(ReportData);\n  private _filterState = inject(ReportFilterStateService);\n  private _destroyRef = inject(DestroyRef);\n  private _elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  private _injector = inject(Injector);\n  private _pinOffsetsRef: AfterRenderRef | null = null;\n\n  constructor() {\n    // Hiding or showing a column moves the pinned columns after it.\n    effect(() => {\n      this.hidden();\n      untracked(() => this._schedulePinOffsets());\n    });\n  }\n\n  public ngOnInit(): void {\n    const component = this.component();\n    const config = (component.config ?? {}) as ListConfig;\n    this.pivoted.set(!!config.pivotBy?.column);\n    this.showTotals.set(config.totals === true);\n    this.columns.set((config.columns ?? []).map((column) => ({ ...column, numeric: hasNumberFormat(column) })));\n\n    this._initListConfig(config);\n    this._observePinOffsets();\n\n    // A change to any group this list's filters belong to (from the report bar\n    // or the component header strip) re-runs the list.\n    // So does a change of the text in its search box (in the component header).\n    merge(this._filterState.changesFor(component), this._filterState.listSearchChanges(component.id))\n      .pipe(\n        tap(() => this.listComponent()?.reload()),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe();\n  }\n\n  private _initListConfig(config: ListConfig): void {\n    // The viewer's last sort wins over the authored one, so a list recreated\n    // in the same session (page switch, reload after an edit) keeps it.\n    // fs-list holds one sorting column, so it shows the authored sort's first\n    // term; the request sends only that term and the server appends the rest.\n    const sort: ReportSort | undefined = this._filterState.listSort(this.component().id)\n      ?? listSortTerms(config)[0];\n\n    this.listConfig = {\n      // Inside a report component the list is a clean data pane — no status\n      // bar, no reload button (filter changes already refetch).\n      status: false,\n      reload: false,\n      // FsList never touches the URL or persists sort/paging state. The sort\n      // is kept in ReportFilterStateService (setListSort), and paging stays\n      // out of it.\n      queryParam: false,\n      persist: false,\n      sort: sort\n        ? { value: sort.column, direction: sort.direction ?? 'asc' }\n        : undefined,\n      // Load-more: the list keeps a fixed, scrollable height and appends the\n      // next page in place instead of swapping pages. The button is pinned to\n      // the bottom of the scroll pane (see component SCSS).\n      //\n      // Uses the Offset strategy (offset + limit) rather than Many: in\n      // @firestitch/list the pagination template resolves `hasManyStrategy`\n      // BEFORE `loadMoreEnabled`, and Many renders a forward-only page pager —\n      // so Many would suppress the load-more button entirely. Offset + loadMore\n      // is the combination that actually renders and appends. `_fetch` already\n      // derives `page` from `offset`, so the server-side wrap is unaffected.\n      paging: {\n        limit: config.pageSize ?? 25,\n        strategy: PaginationStrategy.Offset,\n      },\n      loadMore: {\n        enabled: true,\n        label: 'Load more',\n        buttonType: 'stroked',\n      },\n      fetch: (query: any) => this._fetch(query),\n    };\n  }\n\n  private _fetch(query: any): Observable<{ data: Record<string, unknown>[]; paging: any }> {\n    // Many/load-more sends `offset` + `limit` (not `page`); derive the page so\n    // the server-side wrap keeps working unchanged. Page strategy still sends\n    // `page` directly.\n    const pageSize = query.limit ?? 25;\n    const page = query.page\n      ?? (query.offset != null ? Math.floor(query.offset / pageSize) + 1 : 1);\n\n    const state: ComponentDataState = {\n      page,\n      pageSize,\n    };\n\n    const order = String(query.order ?? '');\n    if (order) {\n      const [column, direction] = order.split(',');\n      state.sort = { column, direction: direction === 'desc' ? 'desc' : 'asc' };\n    }\n\n    const component = this.component();\n    this._filterState.setListSort(component, state.sort ?? null);\n\n    const search = this._filterState.listSearch(component.id);\n    if (search) {\n      state.search = search;\n    }\n\n    // The groups that match 'any', as every other read of this tile sends\n    // them (tileDataState). The sort and paging above are FsList's own.\n    const { matchAnyGroupIds } = this._filterState.tileState(component);\n    if (matchAnyGroupIds) {\n      state.matchAnyGroupIds = matchAnyGroupIds;\n    }\n\n    // One source for filter values, the same one charts, KPIs and the exports\n    // read, so the list is filtered exactly as its header strip shows.\n    const filters = this._filterState.resolveForComponent(component);\n\n    return this._reportData\n      .componentData(this.reportId(), component.id, filters, state)\n      .pipe(\n        map((data: ComponentData) => {\n          // A cross-tab's headers come back with the rows: the row-key column\n          // first, then one per pivot value. Re-read them on every fetch, since\n          // a filter change can add or remove a column.\n          if (this.pivoted()) {\n            this.columns.set(this._pivotColumns(data));\n            this.truncated.set(!!data.truncated);\n          }\n\n          // Only page 1 carries the notes and the totals; a load-more page\n          // leaves them as they are.\n          if (state.page === 1) {\n            this.searchNote.set(data.searchNote ?? null);\n            this.totals.set(data.totals ?? null);\n            this.totalsNote.set(data.totalsNote ?? null);\n            this.noteData.set(this._noteData(data));\n            this._alignOutputColumns(data);\n          }\n\n          // The server's page size when it sends one (it clamps the request),\n          // the size the paging below hands fs-list too.\n          const size = data.paging?.pageSize ?? state.pageSize;\n          const shown = (state.page - 1) * size + (data.rows?.length ?? 0);\n          this.rowCount.set({ shown, total: data.paging?.total ?? shown });\n\n          // New rows can widen a pinned column, which moves the ones after it.\n          this._schedulePinOffsets();\n\n          return {\n            data: data.rows ?? [],\n            paging: {\n              limit: data.paging?.pageSize ?? state.pageSize,\n              records: data.paging?.total ?? (data.rows?.length ?? 0),\n              page: data.paging?.page ?? state.page,\n            },\n          };\n        }),\n      );\n  }\n\n  // A cross-tab's columns, built from the wire by pivotColumnSpecs(): the same\n  // headings and cell format the PDF and PowerPoint exports use. A cell column\n  // whose measure is a rank or a share (cellMeasures names it) holds numbers\n  // whether or not the grid names a cell format.\n  private _pivotColumns(data: ComponentData): (ListColumn & { numeric: boolean })[] {\n    const config = (this.component().config ?? {}) as ListConfig;\n    const outputCells = Object.keys(listOutputColumns(\n      (data.columns ?? []).slice(1).map((column) => ({ column })),\n      data,\n      [],\n    ));\n\n    return pivotColumnSpecs(config, data, this.formatContext().locale)\n      .map((column) => ({ ...column, numeric: column.numeric || outputCells.includes(column.column) }));\n  }\n\n  private _noteData(data: ComponentData): ComponentNoteData {\n    return {\n      comparison: data.comparison,\n      timeframe: data.timeframe,\n      outputs: data.outputs,\n      cellMeasures: data.cellMeasures,\n      windows: data.windows,\n      granularity: data.granularity,\n    };\n  }\n\n  // A plain list's columns are built before any data arrives, so an output\n  // column that names no format of its own (a rank, a share, a prior that takes\n  // its measure's format) learns it holds numbers from page 1. fs-list reads a\n  // column's alignment only when it builds the column, so a column whose\n  // alignment changes is rebuilt (the template tracks columns by both).\n  private _alignOutputColumns(data: ComponentData): void {\n    if (this.pivoted() || !data.outputs) {\n      return;\n    }\n\n    const columns = this.columns();\n    const aligned = columns.map((column) => ({\n      ...column,\n      numeric: hasNumberFormat(column) || !!data.outputs[column.column],\n    }));\n\n    if (aligned.some((column, index) => column.numeric !== columns[index].numeric)) {\n      this.columns.set(aligned);\n    }\n  }\n\n  // A tile resize reflows the table's auto layout, so the pinned columns'\n  // widths, and with them their offsets, change.\n  private _observePinOffsets(): void {\n    if (this.pinned() < 2 || typeof ResizeObserver === 'undefined') {\n      return;\n    }\n\n    const observer = new ResizeObserver(() => this._schedulePinOffsets());\n    observer.observe(this._elementRef.nativeElement);\n    this._destroyRef.onDestroy(() => observer.disconnect());\n  }\n\n  // Measures the pinned offsets once the next render has laid the table out.\n  // One pending measurement covers every request made before it runs. Only\n  // afterNextRender exists in every Angular version this library runs on.\n  private _schedulePinOffsets(): void {\n    if (this.pinned() < 2 || this._pinOffsetsRef) {\n      return;\n    }\n\n    this._pinOffsetsRef = afterNextRender(() => {\n      this._pinOffsetsRef = null;\n      this._updatePinOffsets();\n    }, { injector: this._injector });\n  }\n\n  // Each pinned column sticks at the summed width of the visible pinned\n  // columns before it. A hidden column renders no header, so the next pinned\n  // one takes its place. A variable is written only when its value changed,\n  // which keeps a resize from restyling the table for nothing.\n  private _updatePinOffsets(): void {\n    const host = this._elementRef.nativeElement;\n    let left = 0;\n\n    for (let index = 0; index < this.pinned(); index++) {\n      const header = host.querySelector<HTMLElement>(`thead th.report-pin-${index}`);\n\n      if (!header) {\n        continue;\n      }\n\n      const name = `--report-pin-left-${index}`;\n      const value = `${Math.round(left * 100) / 100}px`;\n\n      if (host.style.getPropertyValue(name) !== value) {\n        host.style.setProperty(name, value);\n      }\n\n      left += header.getBoundingClientRect().width;\n    }\n  }\n}\n","@if (truncated()) {\n  <div class=\"pivot-truncated\">\n    This grid was built from a partial result, so some columns or values may be missing. Narrow it with a filter.\n  </div>\n}\n\n<!-- The windows a comparison compares, and why it reads as it does. A\n     windowed column's own notes are in its header's tooltip. -->\n<app-report-component-note\n  [data]=\"noteData()\"\n  [windowNotes]=\"false\">\n</app-report-component-note>\n\n<!-- fs-list reads a column's footer template once, as a direct child of\n     fs-list-column, so a list with totals renders its columns in a branch of\n     their own rather than wrapping the footer in an @if. Its header template too,\n     which every column carries: an output column's tooltip says what it holds.\n     Columns are tracked by alignment as well as name, since fs-list reads a\n     column's alignment only when it builds the column. -->\n<fs-list\n  [config]=\"listConfig\"\n  [class.report-totals-empty]=\"!totals()\">\n  @if (showTotals()) {\n    @for (column of columns(); track column.column + ':' + column.numeric) {\n      <fs-list-column\n        [name]=\"column.column\"\n        [title]=\"column.label || column.column\"\n        [show]=\"!hidden().has(column.column)\"\n        [sortable]=\"!pivoted() || $first\"\n        [align]=\"column.numeric ? 'right' : 'left'\"\n        [class]=\"columnClasses(column, $index, pinned())\">\n        <ng-template fs-list-header>\n          <ng-container\n            [ngTemplateOutlet]=\"headerTpl\"\n            [ngTemplateOutletContext]=\"{ column: column }\">\n          </ng-container>\n        </ng-template>\n        <ng-template\n          fs-list-cell\n          let-row=\"row\">\n          <ng-container\n            [ngTemplateOutlet]=\"cellTpl\"\n            [ngTemplateOutletContext]=\"{ $implicit: row[column.column], row: row, column: column }\">\n          </ng-container>\n        </ng-template>\n        <ng-template fs-list-footer>\n          @if (totals()?.[column.column] !== undefined) {\n            <ng-container\n              [ngTemplateOutlet]=\"cellTpl\"\n              [ngTemplateOutletContext]=\"{ $implicit: totals()?.[column.column], row: totals(), column: column }\">\n            </ng-container>\n          } @else if (column.column === totalsLabelColumn()) {\n            {{ totalLabel }}\n          }\n        </ng-template>\n      </fs-list-column>\n    }\n  } @else {\n    @for (column of columns(); track column.column + ':' + column.numeric) {\n      <fs-list-column\n        [name]=\"column.column\"\n        [title]=\"column.label || column.column\"\n        [show]=\"!hidden().has(column.column)\"\n        [sortable]=\"!pivoted() || $first\"\n        [align]=\"column.numeric ? 'right' : 'left'\"\n        [class]=\"columnClasses(column, $index, pinned())\">\n        <ng-template fs-list-header>\n          <ng-container\n            [ngTemplateOutlet]=\"headerTpl\"\n            [ngTemplateOutletContext]=\"{ column: column }\">\n          </ng-container>\n        </ng-template>\n        <ng-template\n          fs-list-cell\n          let-row=\"row\">\n          <ng-container\n            [ngTemplateOutlet]=\"cellTpl\"\n            [ngTemplateOutletContext]=\"{ $implicit: row[column.column], row: row, column: column }\">\n          </ng-container>\n        </ng-template>\n      </fs-list-column>\n    }\n  }\n</fs-list>\n\n@if (caption()) {\n  <div class=\"list-caption small\">\n    {{ caption() }}\n  </div>\n}\n\n<!-- A column's heading, with what an output column holds as its tooltip (an\n     empty one never shows). -->\n<ng-template\n  #headerTpl\n  let-column=\"column\">\n  <span [matTooltip]=\"columnNotes()[column.column] ?? ''\">{{ column.label || column.column }}</span>\n</ng-template>\n\n<!-- One cell, in the body and the totals row alike: an output column by what\n     it holds (its row gives a change its prior), a date column as a day in the\n     report's zone and locale, any other through its number format. -->\n<ng-template\n  #cellTpl\n  let-value\n  let-row=\"row\"\n  let-column=\"column\">\n  @if (outputColumns()[column.column]; as output) {\n    @if (row | fsReportOutput: column : output : formatContext(); as cell) {\n      <span [attr.title]=\"cell.title\">{{ cell.text }}</span>\n    }\n  } @else if (column.format === ReportListColumnFormat.Date) {\n    {{ value | fsReportDate: timezone() : formatContext().locale }}\n  } @else {\n    {{ value | fsReportNumber: column : formatContext() }}\n  }\n</ng-template>\n"]}