@firestitch/report 18.9.0 → 18.10.1

package/esm2022/app/reports/services/report-view.service.mjs

@@ -0,0 +1,218 @@
+import { HttpContext } from '@angular/common/http';
+import { DestroyRef, Injectable, computed, inject, signal } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { DisplayApiError } from '@firestitch/api';
+import { FsMessage } from '@firestitch/message';
+import { EMPTY, of } from 'rxjs';
+import { catchError, map, tap } from 'rxjs/operators';
+import { ReportData } from '../data/report.data';
+import { viewDroppedCount, viewDroppedMessage, withStoredKeys } from '../report-view-config';
+import { ReportFilterStateService } from './report-filter-state.service';
+import * as i0 from "@angular/core";
+// The open report's saved views, per open report beside the state service:
+// the list the viewer may see, the view that is open, the order a report
+// opens in and the calls that change a view. The viewer state stays
+// ReportFilterStateService's: this service puts a view on screen through
+// apply() and reads the screen through snapshot(), base and viewChanged.
+// Nothing here runs for a report whose server does not list 'views'
+// (serves()). A view is opened from the Views menu only: a report keeps no
+// state in the browser URL, so there is no link to a view.
+//
+// The order a report opens in (open(), on its first load only):
+// 1. The viewer's default view.
+// 2. Else the report's authored defaults.
+// A ?page= the report opened with beats the default view's page.
+export class ReportViewService {
+    // The views the viewer may see, names and flags only: its own first, then
+    // the ones others share. Empty until the list is read.
+    views = computed(() => this._views());
+    // The viewer may share its views with everyone.
+    canShare = computed(() => this._canShare());
+    // The open view, with its config as it was read or saved; null while the
+    // screen is on the report's defaults.
+    openView = computed(() => this._openView());
+    // Whether the screen differs from the open view; false with none open.
+    viewChanged = computed(() => !!this._openView() && this._filterState.viewChanged());
+    _reportData = inject(ReportData);
+    _filterState = inject(ReportFilterStateService);
+    _message = inject(FsMessage);
+    _destroyRef = inject(DestroyRef);
+    _views = signal([]);
+    _canShare = signal(false);
+    _openView = signal(null);
+    // The report the views belong to.
+    _reportId = null;
+    // Whether the open report's server keeps saved views.
+    serves(report) {
+        return !!report?.viewerFeatures?.includes('views');
+    }
+    // A report's first load, in the open order above: the state service is
+    // set up for `report` (init) once the list is read, and the screen opened
+    // on the viewer's default view, else on the report's defaults. `pageId` is
+    // the ?page= the report opened with, which beats the view's page. Ends once
+    // the screen is set.
+    open(report, pageId) {
+        this._start(report);
+        return this._readViews(report)
+            .pipe(tap((list) => {
+            this._filterState.init(report);
+            if (list?.myDefault) {
+                this._openOn(list.myDefault, () => this._filterState.apply(list.myDefault.config, pageId));
+            }
+        }), map(() => undefined));
+    }
+    // A later load of the open report (a chat edit, a settings save): the
+    // screen and the open view stay, and the list is read again behind them so
+    // it names what the server holds now.
+    refresh(report) {
+        this._start(report);
+        this._readViews(report)
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe();
+    }
+    // Opens a view picked from the list; its config is read now.
+    pick(reportViewId) {
+        return this._reportData.view(this._reportId, reportViewId)
+            .pipe(tap((view) => this._openOn(view, () => this._filterState.apply(view.config))));
+    }
+    // Closes the open view and puts the screen on the report's defaults.
+    openDefaults() {
+        this._openView.set(null);
+        this._filterState.apply(null);
+    }
+    // Saves the screen as a new view, which becomes the open view. The screen
+    // is already the view, so nothing is applied again.
+    saveAsNew(view) {
+        return this._reportData.createView(this._reportId, { ...view, config: this._filterState.snapshot() })
+            .pipe(tap((saved) => {
+            this._openView.set(saved);
+            this._putRow(saved);
+            this._filterState.setBaseToScreen();
+            this._message.success('View saved');
+        }));
+    }
+    // Saves the screen over the open view, keeping the keys this viewer does
+    // not know (withStoredKeys).
+    saveChanges() {
+        const open = this._openView();
+        if (!open) {
+            return EMPTY;
+        }
+        return this._reportData.updateView(this._reportId, open.id, { config: withStoredKeys(open.config, this._filterState.snapshot()) })
+            .pipe(tap((saved) => {
+            this._openView.set(saved);
+            this._putRow(saved);
+            this._filterState.setBaseToScreen();
+            this._message.success('View saved');
+        }));
+    }
+    rename(name) {
+        return this._changeOpen((reportViewId) => this._reportData.updateView(this._reportId, reportViewId, { name }));
+    }
+    // Shares the open view with everyone who may open the report, or stops.
+    share(shared) {
+        return this._changeOpen((reportViewId) => this._reportData.shareView(this._reportId, reportViewId, shared));
+    }
+    // Makes the open view the viewer's default, or stops opening it by default.
+    setDefault(personalDefault) {
+        return this._changeOpen((reportViewId) => this._reportData.setViewDefault(this._reportId, reportViewId, personalDefault));
+    }
+    // Deletes the open view. The screen stays; the report's defaults become
+    // what it is compared with.
+    deleteOpen() {
+        const open = this._openView();
+        if (!open) {
+            return EMPTY;
+        }
+        return this._reportData.deleteView(this._reportId, open.id)
+            .pipe(tap(() => {
+            this._openView.set(null);
+            this._views.update((views) => views.filter((view) => view.id !== open.id));
+            this._filterState.clearBase();
+            this._message.success('View deleted');
+        }));
+    }
+    // Starts over for another report: no list and no open view.
+    _start(report) {
+        if (report.id === this._reportId) {
+            return;
+        }
+        this._reportId = report.id;
+        this._views.set([]);
+        this._canShare.set(false);
+        this._openView.set(null);
+    }
+    // Makes `view` the open view, puts it on screen (`applyView`), and says
+    // how many of its settings no longer apply (and to save it, when the
+    // viewer may).
+    _openOn(view, applyView) {
+        this._openView.set(view);
+        applyView();
+        const note = viewDroppedMessage(viewDroppedCount(view, this._filterState.base()), view.canChange);
+        if (note) {
+            this._message.warning(note);
+        }
+    }
+    // Runs a change on the open view and takes its answer as the open view
+    // and its row in the list.
+    _changeOpen(change) {
+        const open = this._openView();
+        if (!open) {
+            return EMPTY;
+        }
+        return change(open.id)
+            .pipe(tap((view) => {
+            this._openView.set(view);
+            this._putRow(view);
+        }));
+    }
+    // A view's row in the list, replaced or added. A new default clears the
+    // flag on the viewer's other views, as the server does. A new row keeps
+    // the list's order: the viewer's own views first, then the ones others
+    // share.
+    _putRow(view) {
+        const summary = viewSummary(view);
+        this._views.update((views) => {
+            const rows = views.map((row) => (view.personalDefault && row.personalDefault ? { ...row, personalDefault: false } : row));
+            const index = rows.findIndex((row) => row.id === view.id);
+            if (index >= 0) {
+                return rows.map((row, at) => (at === index ? summary : row));
+            }
+            const othersAt = view.mine ? rows.findIndex((row) => !row.mine) : -1;
+            return othersAt < 0
+                ? [...rows, summary]
+                : [...rows.slice(0, othersAt), summary, ...rows.slice(othersAt)];
+        });
+    }
+    // The list, read for `report`; null when it cannot be read. Its answer is
+    // kept only while the report is still the open one.
+    _readViews(report) {
+        return this._reportData.views(report.id, { context: new HttpContext().set(DisplayApiError, false) })
+            .pipe(catchError(() => of(null)), tap((list) => {
+            if (list && report.id === this._reportId) {
+                this._views.set(list.views ?? []);
+                this._canShare.set(!!list.canShare);
+            }
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportViewService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportViewService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportViewService, decorators: [{
+            type: Injectable
+        }] });
+// A view's row as the list holds it: names and flags, no config.
+function viewSummary(view) {
+    return {
+        id: view.id,
+        name: view.name,
+        shared: view.shared,
+        mine: view.mine,
+        personalDefault: view.personalDefault,
+        ownerName: view.ownerName,
+        canChange: view.canChange,
+        canDelete: view.canDelete,
+        modifyDate: view.modifyDate,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-view.service.js","sourceRoot":"","sources":["../../../../../src/app/reports/services/report-view.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpContext } from '@angular/common/http';\nimport { DestroyRef, Injectable, computed, inject, signal } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nimport { DisplayApiError } from '@firestitch/api';\nimport { FsMessage } from '@firestitch/message';\n\nimport { EMPTY, Observable, of } from 'rxjs';\nimport { catchError, map, tap } from 'rxjs/operators';\n\nimport { ReportData } from '../data/report.data';\nimport { ReportViewCreate } from '../interfaces/report-view-create.interface';\nimport { ReportViewDeleted } from '../interfaces/report-view-deleted.interface';\nimport { ReportViewSummary } from '../interfaces/report-view-summary.interface';\nimport { ReportView } from '../interfaces/report-view.interface';\nimport { ReportViews } from '../interfaces/report-views.interface';\nimport { Report } from '../interfaces/report.interface';\nimport { viewDroppedCount, viewDroppedMessage, withStoredKeys } from '../report-view-config';\nimport { ReportFilterStateService } from './report-filter-state.service';\n\n\n// The open report's saved views, per open report beside the state service:\n// the list the viewer may see, the view that is open, the order a report\n// opens in and the calls that change a view. The viewer state stays\n// ReportFilterStateService's: this service puts a view on screen through\n// apply() and reads the screen through snapshot(), base and viewChanged.\n// Nothing here runs for a report whose server does not list 'views'\n// (serves()). A view is opened from the Views menu only: a report keeps no\n// state in the browser URL, so there is no link to a view.\n//\n// The order a report opens in (open(), on its first load only):\n// 1. The viewer's default view.\n// 2. Else the report's authored defaults.\n// A ?page= the report opened with beats the default view's page.\n@Injectable()\nexport class ReportViewService {\n\n  // The views the viewer may see, names and flags only: its own first, then\n  // the ones others share. Empty until the list is read.\n  public readonly views = computed(() => this._views());\n\n  // The viewer may share its views with everyone.\n  public readonly canShare = computed(() => this._canShare());\n\n  // The open view, with its config as it was read or saved; null while the\n  // screen is on the report's defaults.\n  public readonly openView = computed(() => this._openView());\n\n  // Whether the screen differs from the open view; false with none open.\n  public readonly viewChanged = computed(() => !!this._openView() && this._filterState.viewChanged());\n\n  private _reportData = inject(ReportData);\n  private _filterState = inject(ReportFilterStateService);\n  private _message = inject(FsMessage);\n  private _destroyRef = inject(DestroyRef);\n\n  private _views = signal<ReportViewSummary[]>([]);\n  private _canShare = signal(false);\n  private _openView = signal<ReportView | null>(null);\n\n  // The report the views belong to.\n  private _reportId: number | null = null;\n\n  // Whether the open report's server keeps saved views.\n  public serves(report: Report | null): boolean {\n    return !!report?.viewerFeatures?.includes('views');\n  }\n\n  // A report's first load, in the open order above: the state service is\n  // set up for `report` (init) once the list is read, and the screen opened\n  // on the viewer's default view, else on the report's defaults. `pageId` is\n  // the ?page= the report opened with, which beats the view's page. Ends once\n  // the screen is set.\n  public open(report: Report, pageId: number | null): Observable<void> {\n    this._start(report);\n\n    return this._readViews(report)\n      .pipe(\n        tap((list) => {\n          this._filterState.init(report);\n          if (list?.myDefault) {\n            this._openOn(list.myDefault, () => this._filterState.apply(list.myDefault.config, pageId));\n          }\n        }),\n        map(() => undefined),\n      );\n  }\n\n  // A later load of the open report (a chat edit, a settings save): the\n  // screen and the open view stay, and the list is read again behind them so\n  // it names what the server holds now.\n  public refresh(report: Report): void {\n    this._start(report);\n    this._readViews(report)\n      .pipe(takeUntilDestroyed(this._destroyRef))\n      .subscribe();\n  }\n\n  // Opens a view picked from the list; its config is read now.\n  public pick(reportViewId: number): Observable<ReportView> {\n    return this._reportData.view(this._reportId, reportViewId)\n      .pipe(\n        tap((view) => this._openOn(view, () => this._filterState.apply(view.config))),\n      );\n  }\n\n  // Closes the open view and puts the screen on the report's defaults.\n  public openDefaults(): void {\n    this._openView.set(null);\n    this._filterState.apply(null);\n  }\n\n  // Saves the screen as a new view, which becomes the open view. The screen\n  // is already the view, so nothing is applied again.\n  public saveAsNew(view: Omit<ReportViewCreate, 'config'>): Observable<ReportView> {\n    return this._reportData.createView(this._reportId, { ...view, config: this._filterState.snapshot() })\n      .pipe(\n        tap((saved) => {\n          this._openView.set(saved);\n          this._putRow(saved);\n          this._filterState.setBaseToScreen();\n          this._message.success('View saved');\n        }),\n      );\n  }\n\n  // Saves the screen over the open view, keeping the keys this viewer does\n  // not know (withStoredKeys).\n  public saveChanges(): Observable<ReportView> {\n    const open = this._openView();\n    if (!open) {\n      return EMPTY;\n    }\n\n    return this._reportData.updateView(this._reportId, open.id, { config: withStoredKeys(open.config, this._filterState.snapshot()) })\n      .pipe(\n        tap((saved) => {\n          this._openView.set(saved);\n          this._putRow(saved);\n          this._filterState.setBaseToScreen();\n          this._message.success('View saved');\n        }),\n      );\n  }\n\n  public rename(name: string): Observable<ReportView> {\n    return this._changeOpen((reportViewId) => this._reportData.updateView(this._reportId, reportViewId, { name }));\n  }\n\n  // Shares the open view with everyone who may open the report, or stops.\n  public share(shared: boolean): Observable<ReportView> {\n    return this._changeOpen((reportViewId) => this._reportData.shareView(this._reportId, reportViewId, shared));\n  }\n\n  // Makes the open view the viewer's default, or stops opening it by default.\n  public setDefault(personalDefault: boolean): Observable<ReportView> {\n    return this._changeOpen((reportViewId) => this._reportData.setViewDefault(this._reportId, reportViewId, personalDefault));\n  }\n\n  // Deletes the open view. The screen stays; the report's defaults become\n  // what it is compared with.\n  public deleteOpen(): Observable<ReportViewDeleted> {\n    const open = this._openView();\n    if (!open) {\n      return EMPTY;\n    }\n\n    return this._reportData.deleteView(this._reportId, open.id)\n      .pipe(\n        tap(() => {\n          this._openView.set(null);\n          this._views.update((views) => views.filter((view) => view.id !== open.id));\n          this._filterState.clearBase();\n          this._message.success('View deleted');\n        }),\n      );\n  }\n\n  // Starts over for another report: no list and no open view.\n  private _start(report: Report): void {\n    if (report.id === this._reportId) {\n      return;\n    }\n\n    this._reportId = report.id;\n    this._views.set([]);\n    this._canShare.set(false);\n    this._openView.set(null);\n  }\n\n  // Makes `view` the open view, puts it on screen (`applyView`), and says\n  // how many of its settings no longer apply (and to save it, when the\n  // viewer may).\n  private _openOn(view: ReportView, applyView: () => void): void {\n    this._openView.set(view);\n    applyView();\n\n    const note = viewDroppedMessage(viewDroppedCount(view, this._filterState.base()), view.canChange);\n    if (note) {\n      this._message.warning(note);\n    }\n  }\n\n  // Runs a change on the open view and takes its answer as the open view\n  // and its row in the list.\n  private _changeOpen(change: (reportViewId: number) => Observable<ReportView>): Observable<ReportView> {\n    const open = this._openView();\n    if (!open) {\n      return EMPTY;\n    }\n\n    return change(open.id)\n      .pipe(\n        tap((view) => {\n          this._openView.set(view);\n          this._putRow(view);\n        }),\n      );\n  }\n\n  // A view's row in the list, replaced or added. A new default clears the\n  // flag on the viewer's other views, as the server does. A new row keeps\n  // the list's order: the viewer's own views first, then the ones others\n  // share.\n  private _putRow(view: ReportView): void {\n    const summary = viewSummary(view);\n\n    this._views.update((views) => {\n      const rows = views.map((row) => (view.personalDefault && row.personalDefault ? { ...row, personalDefault: false } : row));\n      const index = rows.findIndex((row) => row.id === view.id);\n\n      if (index >= 0) {\n        return rows.map((row, at) => (at === index ? summary : row));\n      }\n\n      const othersAt = view.mine ? rows.findIndex((row) => !row.mine) : -1;\n\n      return othersAt < 0\n        ? [...rows, summary]\n        : [...rows.slice(0, othersAt), summary, ...rows.slice(othersAt)];\n    });\n  }\n\n  // The list, read for `report`; null when it cannot be read. Its answer is\n  // kept only while the report is still the open one.\n  private _readViews(report: Report): Observable<ReportViews | null> {\n    return this._reportData.views(report.id, { context: new HttpContext().set(DisplayApiError, false) })\n      .pipe(\n        catchError(() => of(null)),\n        tap((list) => {\n          if (list && report.id === this._reportId) {\n            this._views.set(list.views ?? []);\n            this._canShare.set(!!list.canShare);\n          }\n        }),\n      );\n  }\n\n}\n\n\n// A view's row as the list holds it: names and flags, no config.\nfunction viewSummary(view: ReportView): ReportViewSummary {\n  return {\n    id: view.id,\n    name: view.name,\n    shared: view.shared,\n    mine: view.mine,\n    personalDefault: view.personalDefault,\n    ownerName: view.ownerName,\n    canChange: view.canChange,\n    canDelete: view.canDelete,\n    modifyDate: view.modifyDate,\n  };\n}\n"]}

package/esm2022/app/reports/tile-data-state.mjs

@@ -0,0 +1,127 @@
+import { isMatchAnyGroup } from './report-filter-items';
+import { isTile } from './report-tile';
+import { isChartGranularity } from './report-view-config';
+// Whether a component is a chart on a time x-axis: the only component the
+// report's group-by grain applies to. A deliberate mirror of the server's
+// ReportQueryRunner::_isTimeSeriesChart, which is canonical and drops the
+// grain for every other component; kept so a product pinned to an older
+// framework does not re-bucket a non-time chart.
+export function isTimeSeriesChart(component) {
+    return component.type === 'chart' && component.config?.xAxis?.kind === 'time';
+}
+// The interaction state one tile's data request carries, read off a view
+// document of the screen (the state service's snapshot()): the group-by grain
+// for a time-series chart, a list's sort, search and hidden columns, a
+// chart's drill path, and, while the groups match 'any', the groups that
+// combine (matchAnyGroupIds). The tile on screen, its CSV, the PDF and
+// PowerPoint collector and the zip all build their state here, so a file
+// always holds what the screen shows. A list's paging is the caller's. Never
+// sets unchangedIfUnreached: that belongs to an on-screen refetch alone.
+//
+// A drill path and the grain may both be sent: the server lets the drilled
+// level win, and a server that does not drill keeps the grain.
+export function tileDataState(report, component, snapshot) {
+    const state = {};
+    if (!isTile(component)) {
+        return state;
+    }
+    const tile = snapshot.tiles?.[component.id];
+    if (isTimeSeriesChart(component) && isChartGranularity(snapshot.groupBy)) {
+        state.frequency = snapshot.groupBy;
+    }
+    if (component.type === 'list') {
+        if (tile?.sort?.column) {
+            state.sort = { ...tile.sort };
+        }
+        if (tile?.search) {
+            state.search = tile.search;
+        }
+        if (tile?.hidden?.length) {
+            state.hiddenColumns = [...tile.hidden];
+        }
+    }
+    if (component.type === 'chart' && tile?.drill?.length) {
+        state.drill = tile.drill.map((step) => ({ ...step }));
+    }
+    const matchAnyGroupIds = tileMatchAnyGroupIds(report, component, snapshot);
+    if (matchAnyGroupIds.length) {
+        state.matchAnyGroupIds = matchAnyGroupIds;
+    }
+    return state;
+}
+// Each tile's state for the zip export (tileDataState), by component id: the
+// tiles of every page, or of `pageId` alone. The zip holds no header or
+// footer tile. A tile with nothing to send is left out, so an untouched report
+// sends no states at all.
+export function zipExportStates(report, snapshot, pageId = null) {
+    const states = {};
+    (report.pages ?? [])
+        .filter((page) => !pageId || page.id === pageId)
+        .flatMap((page) => page.components ?? [])
+        .forEach((component) => {
+        const state = tileDataState(report, component, snapshot);
+        if (Object.keys(state).length) {
+            states[component.id] = state;
+        }
+    });
+    return states;
+}
+// The groups a tile's 'any' combines, in id order: while the snapshot's
+// match is 'any', every eligible group that holds a value. A group the tile
+// has no member of is listed too, so the server can tell a tile that cannot
+// test every group (it then applies none of them and says so). A page group
+// counts only for the tiles of its own page: it is in the report bar of no
+// other page. A header or footer tile is a tile of the page on screen.
+function tileMatchAnyGroupIds(report, component, snapshot) {
+    if (!report) {
+        return [];
+    }
+    return matchAnyGroupIdsOnPage(report, tilePageId(report, component, snapshot), snapshot);
+}
+// The groups a layer's inline values combine (the page values request's
+// matchAnyGroupIds), by the tile rule (tileDataState): while the snapshot's
+// match is 'any', every eligible group that holds a value, in id order. A
+// value has no member of some of them, and the server then applies none of
+// them to it, as it does for such a tile. `layerId` is the page the values
+// sit on; the header and footer's values (any other id) are values of the
+// page on screen, as a header or footer tile is.
+export function valuesMatchAnyGroupIds(report, layerId, snapshot) {
+    if (!report) {
+        return [];
+    }
+    const page = (report.pages ?? []).find((candidate) => candidate.id === layerId);
+    return matchAnyGroupIdsOnPage(report, page?.id ?? snapshot.pageId ?? null, snapshot);
+}
+// While the snapshot's match is 'any': the eligible groups of the report bar
+// on `pageId` that hold a value, in id order.
+function matchAnyGroupIdsOnPage(report, pageId, snapshot) {
+    if (snapshot.match !== 'any') {
+        return [];
+    }
+    return (report.filterGroups ?? [])
+        .filter((group) => isMatchAnyGroup(group, pageId) && holdsValue(snapshot.groups?.[group.id]))
+        .map((group) => group.id)
+        .sort((a, b) => a - b);
+}
+// The page a tile is drawn on: its own page, or, for a header or footer
+// tile, the page on screen. Null when neither is known. An inline value's
+// page is the page whose values hold it, the same way.
+export function tilePageId(report, component, snapshot) {
+    const page = (report.pages ?? [])
+        .find((candidate) => [...(candidate.components ?? []), ...(candidate.values ?? [])]
+        .some((item) => item.id === component.id));
+    return page?.id ?? snapshot.pageId ?? null;
+}
+// Whether a group's stored value holds something a request sends: picks to
+// keep or leave out, text, or a number range end (0 is an end).
+function holdsValue(value) {
+    if (!value) {
+        return false;
+    }
+    return !!value.values?.length
+        || !!value.excludeValues?.length
+        || (typeof value.value === 'string' && !!value.value.trim())
+        || Number.isFinite(value.min)
+        || Number.isFinite(value.max);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tile-data-state.js","sourceRoot":"","sources":["../../../../src/app/reports/tile-data-state.ts"],"names":[],"mappings":"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","sourcesContent":["import { ReportViewConfig } from './interfaces/report-view-config.interface';\nimport {\n  ComponentDataState,\n  FilterGroupDefault,\n  Report,\n  ReportComponent,\n} from './interfaces/report.interface';\nimport { isMatchAnyGroup } from './report-filter-items';\nimport { isTile } from './report-tile';\nimport { isChartGranularity } from './report-view-config';\n\n\n// Whether a component is a chart on a time x-axis: the only component the\n// report's group-by grain applies to. A deliberate mirror of the server's\n// ReportQueryRunner::_isTimeSeriesChart, which is canonical and drops the\n// grain for every other component; kept so a product pinned to an older\n// framework does not re-bucket a non-time chart.\nexport function isTimeSeriesChart(component: ReportComponent): boolean {\n  return component.type === 'chart' && component.config?.xAxis?.kind === 'time';\n}\n\n\n// The interaction state one tile's data request carries, read off a view\n// document of the screen (the state service's snapshot()): the group-by grain\n// for a time-series chart, a list's sort, search and hidden columns, a\n// chart's drill path, and, while the groups match 'any', the groups that\n// combine (matchAnyGroupIds). The tile on screen, its CSV, the PDF and\n// PowerPoint collector and the zip all build their state here, so a file\n// always holds what the screen shows. A list's paging is the caller's. Never\n// sets unchangedIfUnreached: that belongs to an on-screen refetch alone.\n//\n// A drill path and the grain may both be sent: the server lets the drilled\n// level win, and a server that does not drill keeps the grain.\nexport function tileDataState(\n  report: Report | null,\n  component: ReportComponent,\n  snapshot: ReportViewConfig,\n): ComponentDataState {\n  const state: ComponentDataState = {};\n\n  if (!isTile(component)) {\n    return state;\n  }\n\n  const tile = snapshot.tiles?.[component.id];\n\n  if (isTimeSeriesChart(component) && isChartGranularity(snapshot.groupBy)) {\n    state.frequency = snapshot.groupBy;\n  }\n\n  if (component.type === 'list') {\n    if (tile?.sort?.column) {\n      state.sort = { ...tile.sort };\n    }\n    if (tile?.search) {\n      state.search = tile.search;\n    }\n    if (tile?.hidden?.length) {\n      state.hiddenColumns = [...tile.hidden];\n    }\n  }\n\n  if (component.type === 'chart' && tile?.drill?.length) {\n    state.drill = tile.drill.map((step) => ({ ...step }));\n  }\n\n  const matchAnyGroupIds = tileMatchAnyGroupIds(report, component, snapshot);\n  if (matchAnyGroupIds.length) {\n    state.matchAnyGroupIds = matchAnyGroupIds;\n  }\n\n  return state;\n}\n\n\n// Each tile's state for the zip export (tileDataState), by component id: the\n// tiles of every page, or of `pageId` alone. The zip holds no header or\n// footer tile. A tile with nothing to send is left out, so an untouched report\n// sends no states at all.\nexport function zipExportStates(\n  report: Report,\n  snapshot: ReportViewConfig,\n  pageId: number | null = null,\n): Record<number, ComponentDataState> {\n  const states: Record<number, ComponentDataState> = {};\n\n  (report.pages ?? [])\n    .filter((page) => !pageId || page.id === pageId)\n    .flatMap((page) => page.components ?? [])\n    .forEach((component) => {\n      const state = tileDataState(report, component, snapshot);\n\n      if (Object.keys(state).length) {\n        states[component.id] = state;\n      }\n    });\n\n  return states;\n}\n\n\n// The groups a tile's 'any' combines, in id order: while the snapshot's\n// match is 'any', every eligible group that holds a value. A group the tile\n// has no member of is listed too, so the server can tell a tile that cannot\n// test every group (it then applies none of them and says so). A page group\n// counts only for the tiles of its own page: it is in the report bar of no\n// other page. A header or footer tile is a tile of the page on screen.\nfunction tileMatchAnyGroupIds(report: Report | null, component: ReportComponent, snapshot: ReportViewConfig): number[] {\n  if (!report) {\n    return [];\n  }\n\n  return matchAnyGroupIdsOnPage(report, tilePageId(report, component, snapshot), snapshot);\n}\n\n\n// The groups a layer's inline values combine (the page values request's\n// matchAnyGroupIds), by the tile rule (tileDataState): while the snapshot's\n// match is 'any', every eligible group that holds a value, in id order. A\n// value has no member of some of them, and the server then applies none of\n// them to it, as it does for such a tile. `layerId` is the page the values\n// sit on; the header and footer's values (any other id) are values of the\n// page on screen, as a header or footer tile is.\nexport function valuesMatchAnyGroupIds(\n  report: Report | null,\n  layerId: number | null,\n  snapshot: ReportViewConfig,\n): number[] {\n  if (!report) {\n    return [];\n  }\n\n  const page = (report.pages ?? []).find((candidate) => candidate.id === layerId);\n\n  return matchAnyGroupIdsOnPage(report, page?.id ?? snapshot.pageId ?? null, snapshot);\n}\n\n\n// While the snapshot's match is 'any': the eligible groups of the report bar\n// on `pageId` that hold a value, in id order.\nfunction matchAnyGroupIdsOnPage(report: Report, pageId: number | null, snapshot: ReportViewConfig): number[] {\n  if (snapshot.match !== 'any') {\n    return [];\n  }\n\n  return (report.filterGroups ?? [])\n    .filter((group) => isMatchAnyGroup(group, pageId) && holdsValue(snapshot.groups?.[group.id]))\n    .map((group) => group.id)\n    .sort((a, b) => a - b);\n}\n\n\n// The page a tile is drawn on: its own page, or, for a header or footer\n// tile, the page on screen. Null when neither is known. An inline value's\n// page is the page whose values hold it, the same way.\nexport function tilePageId(report: Report, component: ReportComponent, snapshot: ReportViewConfig): number | null {\n  const page = (report.pages ?? [])\n    .find((candidate) => [...(candidate.components ?? []), ...(candidate.values ?? [])]\n      .some((item) => item.id === component.id));\n\n  return page?.id ?? snapshot.pageId ?? null;\n}\n\n\n// Whether a group's stored value holds something a request sends: picks to\n// keep or leave out, text, or a number range end (0 is an end).\nfunction holdsValue(value: FilterGroupDefault | null | undefined): boolean {\n  if (!value) {\n    return false;\n  }\n\n  return !!value.values?.length\n    || !!value.excludeValues?.length\n    || (typeof value.value === 'string' && !!value.value.trim())\n    || Number.isFinite(value.min)\n    || Number.isFinite(value.max);\n}\n"]}

package/esm2022/app/reports/tile-loads.mjs

@@ -0,0 +1,38 @@
+import { catchError, filter, map, merge, of, switchMap, timer } from 'rxjs';
+// A sweep of changes (a few filters set in a row, every value of an applied
+// view) settles for this long before a tile refetches, so the sweep costs one
+// request, not one per change.
+export const TILE_REFRESH_DEBOUNCE_MS = 300;
+// A tile's data as one stream: the first load at once, then one load per
+// settled burst of refresh triggers.
+//
+// - Each trigger starts over (switchMap): it cancels the wait for the one
+//   before it and the request in flight, then waits for the sweep to settle.
+//   So an answer to an older request never lands, not even while the next
+//   load still waits, and the bar stays on until the settled load answers.
+// - Each load notes the state version it was sent under (stateVersion), and
+//   its answer is dropped when the version has moved since. apply() and
+//   resetToBase() move the version and announce a full change together, so
+//   the load for the new state is already on its way.
+// - A failed load ends only itself: its message comes through as the answer,
+//   and the next trigger loads again.
+export function tileLoads(refresh$, load, version) {
+    return merge(of(0), refresh$.pipe(map(() => TILE_REFRESH_DEBOUNCE_MS)))
+        .pipe(switchMap((wait) => (wait ? timer(wait) : of(0))
+        .pipe(switchMap(() => oneLoad(load, version)))));
+}
+// One request: its answer, or its failure as a message, dropped when the
+// state version moved while it was out.
+function oneLoad(load, version) {
+    const sentAt = version();
+    return load()
+        .pipe(map((data) => ({ data, error: null })), catchError((error) => of({ data: null, error: loadErrorMessage(error) })), filter(() => version() === sentAt));
+}
+// What a failed request says: the server's message, else the error's own,
+// else a plain fallback.
+function loadErrorMessage(error) {
+    const failure = error;
+    const message = failure?.error?.message ?? failure?.message;
+    return typeof message === 'string' && message ? message : 'Failed to load data';
+}
+//# sourceMappingURL=data:application/json;base64,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