@firestitch/report 18.9.0 → 18.10.0

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

@@ -0,0 +1,358 @@
+import { HttpContext } from '@angular/common/http';
+import { DestroyRef, Injectable, computed, inject, signal } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { DisplayApiError, ProcessApiError } from '@firestitch/api';
+import { FsMessage } from '@firestitch/message';
+import { EMPTY, of } from 'rxjs';
+import { catchError, map, switchMap, tap } from 'rxjs/operators';
+import { ReportData } from '../data/report.data';
+import { listSortTerms } from '../list-config';
+import { URL_TOO_LONG_MESSAGE, hasReportUrlState, paramsToViewConfig, readReportUrlLink, reportParamsToClear, urlValueNames, viewConfigToParams, } from '../report-url-state';
+import { REPORT_VIEW_CONFIG_VERSION, VIEW_NOT_AVAILABLE_MESSAGE, toStoredGroupValue, viewConfigDiff, 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, the calls that change a view, and the link the screen writes.
+// 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()); such a report keeps the link it always had.
+//
+// The order a report opens in (open(), on its first load only):
+// 1. A link that carries state (any owned key, match or rv). rv names the shared
+//    view it is a diff from; one the viewer cannot open leaves the diff on
+//    the report's defaults, with a note. rpv never changes the screen: when
+//    the viewer owns that view it is the open view, and the screen is
+//    compared with it. The tiles wait for that one view only; the list loads
+//    behind them. A link with rpv and no state (the owner's view was open on
+//    the report's defaults) is a link for the owner only; for anyone else
+//    it is no link.
+// 2. Else the viewer's default view.
+// 3. Else the report's authored defaults.
+// A page in the link beats a view's page.
+//
+// The link (urlParams): while a shared view is open, rv and what differs
+// from it; while one of the viewer's own views is open, or when the screen
+// went back to something a link cannot say on top of the shared view (see
+// viewConfigDiff), everything that differs from the report's defaults, and
+// rpv when the viewer owns the open view. Sharing the open view, or no
+// longer sharing it, writes the link again.
+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;
+    // The note that the screen is too long for a link shows once per report.
+    _tooLongShown = false;
+    // 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) and the screen opened on a link (`params`,
+    // the URL's query params), a default view or the report's defaults.
+    // `pageId` is the page the link names, which beats a view's page. Ends
+    // once the screen is set; the list may still be loading behind it.
+    open(report, params, pageId) {
+        this._start(report);
+        const page = pageId ? { v: REPORT_VIEW_CONFIG_VERSION, pageId } : null;
+        const link = readReportUrlLink(params);
+        const state = hasReportUrlState(params, report.filterGroups ?? []);
+        if (!state && !link.personalViewId) {
+            return this._openDefault(report, page);
+        }
+        const linkDiff = { ...paramsToViewConfig(params, report.filterGroups ?? []), ...page };
+        const viewId = link.viewId ?? link.personalViewId;
+        return (viewId ? this._readView(report.id, viewId) : of(null))
+            .pipe(switchMap((view) => {
+            // A link that names only a personal view (its screen was the
+            // report's defaults) is the owner's link; for anyone else it says
+            // nothing, and the report opens as it would with no link.
+            if (!state && !view?.mine) {
+                return this._openDefault(report, page);
+            }
+            this._filterState.init(report);
+            this._openLink(link, view, linkDiff);
+            this._readViews(report)
+                .pipe(takeUntilDestroyed(this._destroyRef))
+                .subscribe();
+            return of(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');
+        }));
+    }
+    // The query params that make the URL carry the screen (see the class
+    // comment), spread over the owned keys `current` carries so the ones the
+    // screen no longer needs are removed. The host adds its page key.
+    // A select's value is named by `name`, else by the name `current` carries
+    // for it.
+    urlParams(current, name = () => null) {
+        const currentName = urlValueNames(current, this._reportGroups());
+        const write = this._linkWrite((groupId, value) => name(groupId, value) ?? currentName(groupId, value));
+        if (write.tooLong && !this._tooLongShown) {
+            this._tooLongShown = true;
+            this._message.warning(URL_TOO_LONG_MESSAGE);
+        }
+        return { ...reportParamsToClear(current, this._reportGroups()), ...write.params };
+    }
+    // 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);
+        this._tooLongShown = false;
+    }
+    // No link: the viewer's default view, else the report's defaults, once the
+    // list is read.
+    _openDefault(report, page) {
+        return this._readViews(report)
+            .pipe(tap((list) => {
+            this._filterState.init(report);
+            if (list?.myDefault) {
+                this._openOn(list.myDefault, () => this._filterState.apply(list.myDefault.config, page));
+            }
+        }), map(() => undefined));
+    }
+    // A link with state: on the shared view rv names, else on the report's
+    // defaults; rpv's view is the open view only when the viewer owns it.
+    _openLink(link, view, linkDiff) {
+        if (link.viewId && view) {
+            this._openOn(view, () => this._filterState.apply(view.config, linkDiff));
+            return;
+        }
+        if (!link.viewId && view?.mine) {
+            this._openOn(view, () => this._filterState.apply(null, linkDiff, view.config));
+            return;
+        }
+        this._openView.set(null);
+        this._filterState.apply(null, linkDiff);
+        if (link.viewId) {
+            this._message.warning(VIEW_NOT_AVAILABLE_MESSAGE);
+        }
+    }
+    // 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. A change of who may see the view (shared, or
+    // whose it is) changes the key a link names it by, so the URL is written
+    // again.
+    _changeOpen(change) {
+        const open = this._openView();
+        if (!open) {
+            return EMPTY;
+        }
+        return change(open.id)
+            .pipe(tap((view) => {
+            this._openView.set(view);
+            this._putRow(view);
+            if (view.shared !== open.shared || view.mine !== open.mine) {
+                this._filterState.rewriteUrl();
+            }
+        }));
+    }
+    // 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);
+            }
+        }));
+    }
+    // A view a link names; null when the viewer cannot open it. The server
+    // answers 'View not found' for one it cannot see, which must not move the
+    // host to its not-found page.
+    _readView(reportId, reportViewId) {
+        return this._reportData.view(reportId, reportViewId, { context: new HttpContext().set(ProcessApiError, false) })
+            .pipe(catchError(() => of(null)));
+    }
+    // The params the screen writes (see the class comment).
+    _linkWrite(name) {
+        const open = this._openView();
+        const screen = this._filterState.snapshot();
+        const authored = this._filterState.authoredConfig();
+        const authoredSort = (componentId) => this._authoredSort(componentId);
+        if (open?.shared) {
+            // A group the view holds that the base let go of (its authored default
+            // changed while the view was open, and the screen took the new one)
+            // is still the view's value when a link opens the view, so it is
+            // compared with that value and written when the screen differs.
+            const base = this._filterState.base();
+            const linkBase = { ...base, groups: { ...open.config?.groups, ...base.groups } };
+            const diff = viewConfigDiff(linkBase, screen, authored, authoredSort);
+            if (diff) {
+                return viewConfigToParams(this._linkDays(diff), this._reportGroups(), { viewId: open.id }, name);
+            }
+        }
+        const full = viewConfigDiff(authored, screen, authored, authoredSort) ?? screen;
+        const link = open?.mine ? { personalViewId: open.id } : {};
+        return viewConfigToParams(this._linkDays(full), this._reportGroups(), link, name);
+    }
+    // `config` with each rolling range (a relative name, which a view keeps) as
+    // the days it gives today in the report's zone: a link carries days, never a
+    // preset name. A name the report does not know is left as it is, and the
+    // link leaves that group out.
+    _linkDays(config) {
+        if (!config.groups) {
+            return config;
+        }
+        const groups = Object.entries(config.groups)
+            .map(([groupId, value]) => [groupId, this._groupDays(value)]);
+        return { ...config, groups: Object.fromEntries(groups) };
+    }
+    _groupDays(value) {
+        const range = value?.relative ? this._filterState.resolveRelative(value.relative) : null;
+        return range ? toStoredGroupValue('dateRange', { start: range.start, end: range.end }) : value;
+    }
+    // Every filter group of the open report: the link keys each by its label.
+    _reportGroups() {
+        return this._filterState.report()?.filterGroups ?? [];
+    }
+    // A list's authored first sort term, or null for any other component.
+    _authoredSort(componentId) {
+        const report = this._filterState.report();
+        const component = [
+            ...(report?.pages ?? []).flatMap((page) => page.components ?? []),
+            ...(report?.master?.components ?? []),
+        ].find((candidate) => candidate.id === componentId);
+        return component?.type === 'list' ? listSortTerms(component.config)[0] ?? null : null;
+    }
+    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';\nimport { ParamMap, Params } from '@angular/router';\n\nimport { DisplayApiError, ProcessApiError } from '@firestitch/api';\nimport { FsMessage } from '@firestitch/message';\n\nimport { EMPTY, Observable, of } from 'rxjs';\nimport { catchError, map, switchMap, tap } from 'rxjs/operators';\n\nimport { ReportData } from '../data/report.data';\nimport { ReportUrlLink } from '../interfaces/report-url-link.interface';\nimport { ReportUrlValueName } from '../interfaces/report-url-value-name.type';\nimport { ReportUrlWrite } from '../interfaces/report-url-write.interface';\nimport { ReportViewConfig } from '../interfaces/report-view-config.interface';\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 { FilterGroupDefault, Report, ReportFilterGroup, ReportSort } from '../interfaces/report.interface';\nimport { listSortTerms } from '../list-config';\nimport {\n  URL_TOO_LONG_MESSAGE, hasReportUrlState, paramsToViewConfig, readReportUrlLink, reportParamsToClear,\n  urlValueNames, viewConfigToParams,\n} from '../report-url-state';\nimport {\n  REPORT_VIEW_CONFIG_VERSION, VIEW_NOT_AVAILABLE_MESSAGE, toStoredGroupValue, viewConfigDiff, viewDroppedCount,\n  viewDroppedMessage, withStoredKeys,\n} 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, the calls that change a view, and the link the screen writes.\n// The viewer state stays ReportFilterStateService's: this service puts a\n// view on screen through apply() and reads the screen through snapshot(),\n// base and viewChanged. Nothing here runs for a report whose server does not\n// list 'views' (serves()); such a report keeps the link it always had.\n//\n// The order a report opens in (open(), on its first load only):\n// 1. A link that carries state (any owned key, match or rv). rv names the shared\n//    view it is a diff from; one the viewer cannot open leaves the diff on\n//    the report's defaults, with a note. rpv never changes the screen: when\n//    the viewer owns that view it is the open view, and the screen is\n//    compared with it. The tiles wait for that one view only; the list loads\n//    behind them. A link with rpv and no state (the owner's view was open on\n//    the report's defaults) is a link for the owner only; for anyone else\n//    it is no link.\n// 2. Else the viewer's default view.\n// 3. Else the report's authored defaults.\n// A page in the link beats a view's page.\n//\n// The link (urlParams): while a shared view is open, rv and what differs\n// from it; while one of the viewer's own views is open, or when the screen\n// went back to something a link cannot say on top of the shared view (see\n// viewConfigDiff), everything that differs from the report's defaults, and\n// rpv when the viewer owns the open view. Sharing the open view, or no\n// longer sharing it, writes the link again.\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  // The note that the screen is too long for a link shows once per report.\n  private _tooLongShown = false;\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) and the screen opened on a link (`params`,\n  // the URL's query params), a default view or the report's defaults.\n  // `pageId` is the page the link names, which beats a view's page. Ends\n  // once the screen is set; the list may still be loading behind it.\n  public open(report: Report, params: Params, pageId: number | null): Observable<void> {\n    this._start(report);\n    const page: ReportViewConfig | null = pageId ? { v: REPORT_VIEW_CONFIG_VERSION, pageId } : null;\n    const link = readReportUrlLink(params);\n    const state = hasReportUrlState(params, report.filterGroups ?? []);\n\n    if (!state && !link.personalViewId) {\n      return this._openDefault(report, page);\n    }\n\n    const linkDiff: ReportViewConfig = { ...paramsToViewConfig(params, report.filterGroups ?? []), ...page };\n    const viewId = link.viewId ?? link.personalViewId;\n\n    return (viewId ? this._readView(report.id, viewId) : of(null))\n      .pipe(\n        switchMap((view) => {\n          // A link that names only a personal view (its screen was the\n          // report's defaults) is the owner's link; for anyone else it says\n          // nothing, and the report opens as it would with no link.\n          if (!state && !view?.mine) {\n            return this._openDefault(report, page);\n          }\n\n          this._filterState.init(report);\n          this._openLink(link, view, linkDiff);\n          this._readViews(report)\n            .pipe(takeUntilDestroyed(this._destroyRef))\n            .subscribe();\n\n          return of(undefined);\n        }),\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  // The query params that make the URL carry the screen (see the class\n  // comment), spread over the owned keys `current` carries so the ones the\n  // screen no longer needs are removed. The host adds its page key.\n  // A select's value is named by `name`, else by the name `current` carries\n  // for it.\n  public urlParams(current: ParamMap, name: ReportUrlValueName = () => null): Params {\n    const currentName = urlValueNames(current, this._reportGroups());\n    const write = this._linkWrite((groupId, value) => name(groupId, value) ?? currentName(groupId, value));\n\n    if (write.tooLong && !this._tooLongShown) {\n      this._tooLongShown = true;\n      this._message.warning(URL_TOO_LONG_MESSAGE);\n    }\n\n    return { ...reportParamsToClear(current, this._reportGroups()), ...write.params };\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    this._tooLongShown = false;\n  }\n\n  // No link: the viewer's default view, else the report's defaults, once the\n  // list is read.\n  private _openDefault(report: Report, page: ReportViewConfig | null): Observable<void> {\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, page));\n          }\n        }),\n        map(() => undefined),\n      );\n  }\n\n  // A link with state: on the shared view rv names, else on the report's\n  // defaults; rpv's view is the open view only when the viewer owns it.\n  private _openLink(link: ReportUrlLink, view: ReportView | null, linkDiff: ReportViewConfig): void {\n    if (link.viewId && view) {\n      this._openOn(view, () => this._filterState.apply(view.config, linkDiff));\n\n      return;\n    }\n\n    if (!link.viewId && view?.mine) {\n      this._openOn(view, () => this._filterState.apply(null, linkDiff, view.config));\n\n      return;\n    }\n\n    this._openView.set(null);\n    this._filterState.apply(null, linkDiff);\n\n    if (link.viewId) {\n      this._message.warning(VIEW_NOT_AVAILABLE_MESSAGE);\n    }\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. A change of who may see the view (shared, or\n  // whose it is) changes the key a link names it by, so the URL is written\n  // again.\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          if (view.shared !== open.shared || view.mine !== open.mine) {\n            this._filterState.rewriteUrl();\n          }\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  // A view a link names; null when the viewer cannot open it. The server\n  // answers 'View not found' for one it cannot see, which must not move the\n  // host to its not-found page.\n  private _readView(reportId: number, reportViewId: number): Observable<ReportView | null> {\n    return this._reportData.view(reportId, reportViewId, { context: new HttpContext().set(ProcessApiError, false) })\n      .pipe(catchError(() => of(null)));\n  }\n\n  // The params the screen writes (see the class comment).\n  private _linkWrite(name: ReportUrlValueName): ReportUrlWrite {\n    const open = this._openView();\n    const screen = this._filterState.snapshot();\n    const authored = this._filterState.authoredConfig();\n    const authoredSort = (componentId: number) => this._authoredSort(componentId);\n\n    if (open?.shared) {\n      // A group the view holds that the base let go of (its authored default\n      // changed while the view was open, and the screen took the new one)\n      // is still the view's value when a link opens the view, so it is\n      // compared with that value and written when the screen differs.\n      const base = this._filterState.base();\n      const linkBase: ReportViewConfig = { ...base, groups: { ...open.config?.groups, ...base.groups } };\n      const diff = viewConfigDiff(linkBase, screen, authored, authoredSort);\n\n      if (diff) {\n        return viewConfigToParams(this._linkDays(diff), this._reportGroups(), { viewId: open.id }, name);\n      }\n    }\n\n    const full = viewConfigDiff(authored, screen, authored, authoredSort) ?? screen;\n\n    const link = open?.mine ? { personalViewId: open.id } : {};\n\n    return viewConfigToParams(this._linkDays(full), this._reportGroups(), link, name);\n  }\n\n  // `config` with each rolling range (a relative name, which a view keeps) as\n  // the days it gives today in the report's zone: a link carries days, never a\n  // preset name. A name the report does not know is left as it is, and the\n  // link leaves that group out.\n  private _linkDays(config: ReportViewConfig): ReportViewConfig {\n    if (!config.groups) {\n      return config;\n    }\n\n    const groups = Object.entries(config.groups)\n      .map(([groupId, value]) => [groupId, this._groupDays(value)]);\n\n    return { ...config, groups: Object.fromEntries(groups) };\n  }\n\n  private _groupDays(value: FilterGroupDefault | null): FilterGroupDefault | null {\n    const range = value?.relative ? this._filterState.resolveRelative(value.relative) : null;\n\n    return range ? toStoredGroupValue('dateRange', { start: range.start, end: range.end }) : value;\n  }\n\n  // Every filter group of the open report: the link keys each by its label.\n  private _reportGroups(): ReportFilterGroup[] {\n    return this._filterState.report()?.filterGroups ?? [];\n  }\n\n  // A list's authored first sort term, or null for any other component.\n  private _authoredSort(componentId: number): ReportSort | null {\n    const report = this._filterState.report();\n    const component = [\n      ...(report?.pages ?? []).flatMap((page) => page.components ?? []),\n      ...(report?.master?.components ?? []),\n    ].find((candidate) => candidate.id === componentId);\n\n    return component?.type === 'list' ? listSortTerms(component.config)[0] ?? null : null;\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"]}