@firestitch/report 18.9.0 → 18.10.1

package/esm2022/app/reports/report-view-menu.mjs

@@ -0,0 +1,119 @@
+export const VIEWS_LABEL = 'Views';
+export const EDITED_TOOLTIP = 'The screen differs from this view';
+export const SAVE_AS_TITLE = 'Save as new view';
+export const RENAME_TITLE = 'Rename view';
+export const CROSS_FILTER_NOTE = 'Cross-filters are temporary and are not saved.';
+export const VIEW_NAME_BLANK = 'Enter a name';
+// The server's limit on a view's name.
+export const VIEW_NAME_MAX_LENGTH = 100;
+// The menu for the open view (null when none is open), the views the viewer
+// may see, whether the screen differs from the open view, and whether the
+// viewer may share its views.
+export function viewMenuItems(open, views, edited, canShare) {
+    const rows = [
+        ...views.filter((view) => view.mine),
+        ...views.filter((view) => !view.mine),
+    ].map((view) => viewRow(view, open, edited));
+    const actions = openViewActions(open, edited, canShare);
+    const resets = [
+        ...(open && edited ? [action('resetToView', `Reset to "${open.name}"`)] : []),
+        action('resetToDefaults', 'Reset to report defaults'),
+    ];
+    return [
+        ...rows,
+        ...withDivider(actions, rows.length > 0),
+        ...withDivider(resets, true),
+    ];
+}
+// The picker's label: 'Views', or the open view's name, marked while the
+// screen differs from it.
+export function pickerLabel(open, edited) {
+    if (!open) {
+        return VIEWS_LABEL;
+    }
+    return edited ? `${open.name} (edited)` : open.name;
+}
+// The picker's tooltip: only while the screen differs from the open view.
+export function pickerTooltip(open, edited) {
+    return open && edited ? EDITED_TOOLTIP : null;
+}
+// The question before a view is deleted. A shared view says that everyone
+// loses it.
+export function deletePromptText(view) {
+    const question = `Delete the view "${view.name}"?`;
+    return view.shared ? `${question} Everyone it is shared with loses it.` : question;
+}
+// The line the save dialog shows under the name, or null: a cross-filter is
+// on, and it does not go into the view.
+export function saveDialogNote(hasCrossFilter) {
+    return hasCrossFilter ? CROSS_FILTER_NOTE : null;
+}
+// A name made of spaces only is no name; the server trims it.
+export function viewNameError(name) {
+    return (name ?? '').trim() ? null : VIEW_NAME_BLANK;
+}
+function viewRow(view, open, edited) {
+    const isOpen = view.id === open?.id;
+    return {
+        kind: 'view',
+        label: view.name,
+        disabled: isOpen && !edited,
+        tooltip: viewTooltip(view),
+        divider: false,
+        viewId: view.id,
+        open: isOpen,
+        icon: viewIcon(view),
+    };
+}
+// Who shared a view of someone else's; whether one of the viewer's own opens
+// by default or is shared.
+function viewTooltip(view) {
+    if (!view.mine) {
+        return view.ownerName ? `Shared by ${view.ownerName}` : 'Shared with everyone';
+    }
+    if (view.personalDefault && view.shared) {
+        return 'Opens by default, shared with everyone';
+    }
+    if (view.personalDefault) {
+        return 'Opens by default';
+    }
+    return view.shared ? 'Shared with everyone' : null;
+}
+// The open row keeps this icon too; its check is drawn beside it.
+function viewIcon(view) {
+    if (!view.mine) {
+        return 'people';
+    }
+    return view.personalDefault ? 'star' : null;
+}
+// The rows that act on the open view; with none open, only Save as new view.
+function openViewActions(open, edited, canShare) {
+    const items = [];
+    if (open?.canChange && edited) {
+        items.push(action('saveChanges', 'Save changes'));
+    }
+    items.push(action('saveAsNew', 'Save as new view...'));
+    if (open?.canChange) {
+        items.push(action('rename', 'Rename...'));
+    }
+    if (open?.mine) {
+        items.push(open.personalDefault
+            ? action('clearDefault', 'Stop opening it by default')
+            : action('setDefault', 'Make it my default'));
+    }
+    if (open?.mine && canShare) {
+        items.push(open.shared ? action('unshare', 'Stop sharing') : action('share', 'Share with everyone'));
+    }
+    if (open?.canDelete) {
+        items.push(action('delete', 'Delete...'));
+    }
+    return items;
+}
+function action(kind, label) {
+    return { kind, label, disabled: false, tooltip: null, divider: false, viewId: null, open: false, icon: null };
+}
+// The same rows, the first with a line above it when `divider` is set.
+function withDivider(items, divider) {
+    return items.map((item, index) => (index === 0 && divider ? { ...item, divider: true } : item));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-view-menu.js","sourceRoot":"","sources":["../../../../src/app/reports/report-view-menu.ts"],"names":[],"mappings":"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","sourcesContent":["// What the Views picker shows: its label, its menu and the words of its\n// prompts. Pure, so the node harness runs every case; the picker\n// (ReportViewPickerComponent) only draws the rows and runs the one clicked.\n//\n// The menu, top to bottom:\n// - The viewer's own views, then the views others share (a people icon and\n//   'Shared by <name>'). The open view has a check beside its own icon and\n//   cannot be picked again while the screen still shows it; the viewer's\n//   default has a star.\n// - The actions on the open view. Save changes only while the screen\n//   differs from a view the viewer may change; Rename only on a view the\n//   viewer may change; the default and sharing rows only on the viewer's\n//   own view, and sharing only when the viewer may share; Delete only on a\n//   view the viewer may delete. Save as new view is always there.\n// - Reset to the open view while the screen differs from it, and Reset to\n//   report defaults.\nimport { ReportViewMenuItem } from './interfaces/report-view-menu-item.interface';\nimport { ReportViewSummary } from './interfaces/report-view-summary.interface';\n\n\nexport const VIEWS_LABEL = 'Views';\nexport const EDITED_TOOLTIP = 'The screen differs from this view';\nexport const SAVE_AS_TITLE = 'Save as new view';\nexport const RENAME_TITLE = 'Rename view';\nexport const CROSS_FILTER_NOTE = 'Cross-filters are temporary and are not saved.';\nexport const VIEW_NAME_BLANK = 'Enter a name';\n\n// The server's limit on a view's name.\nexport const VIEW_NAME_MAX_LENGTH = 100;\n\n\n// The menu for the open view (null when none is open), the views the viewer\n// may see, whether the screen differs from the open view, and whether the\n// viewer may share its views.\nexport function viewMenuItems(\n  open: ReportViewSummary | null,\n  views: readonly ReportViewSummary[],\n  edited: boolean,\n  canShare: boolean,\n): ReportViewMenuItem[] {\n  const rows = [\n    ...views.filter((view) => view.mine),\n    ...views.filter((view) => !view.mine),\n  ].map((view) => viewRow(view, open, edited));\n  const actions = openViewActions(open, edited, canShare);\n  const resets: ReportViewMenuItem[] = [\n    ...(open && edited ? [action('resetToView', `Reset to \"${open.name}\"`)] : []),\n    action('resetToDefaults', 'Reset to report defaults'),\n  ];\n\n  return [\n    ...rows,\n    ...withDivider(actions, rows.length > 0),\n    ...withDivider(resets, true),\n  ];\n}\n\n// The picker's label: 'Views', or the open view's name, marked while the\n// screen differs from it.\nexport function pickerLabel(open: Pick<ReportViewSummary, 'name'> | null, edited: boolean): string {\n  if (!open) {\n    return VIEWS_LABEL;\n  }\n\n  return edited ? `${open.name} (edited)` : open.name;\n}\n\n// The picker's tooltip: only while the screen differs from the open view.\nexport function pickerTooltip(open: Pick<ReportViewSummary, 'name'> | null, edited: boolean): string | null {\n  return open && edited ? EDITED_TOOLTIP : null;\n}\n\n// The question before a view is deleted. A shared view says that everyone\n// loses it.\nexport function deletePromptText(view: Pick<ReportViewSummary, 'name' | 'shared'>): string {\n  const question = `Delete the view \"${view.name}\"?`;\n\n  return view.shared ? `${question} Everyone it is shared with loses it.` : question;\n}\n\n// The line the save dialog shows under the name, or null: a cross-filter is\n// on, and it does not go into the view.\nexport function saveDialogNote(hasCrossFilter: boolean): string | null {\n  return hasCrossFilter ? CROSS_FILTER_NOTE : null;\n}\n\n// A name made of spaces only is no name; the server trims it.\nexport function viewNameError(name: string | null | undefined): string | null {\n  return (name ?? '').trim() ? null : VIEW_NAME_BLANK;\n}\n\n\nfunction viewRow(view: ReportViewSummary, open: ReportViewSummary | null, edited: boolean): ReportViewMenuItem {\n  const isOpen = view.id === open?.id;\n\n  return {\n    kind: 'view',\n    label: view.name,\n    disabled: isOpen && !edited,\n    tooltip: viewTooltip(view),\n    divider: false,\n    viewId: view.id,\n    open: isOpen,\n    icon: viewIcon(view),\n  };\n}\n\n// Who shared a view of someone else's; whether one of the viewer's own opens\n// by default or is shared.\nfunction viewTooltip(view: ReportViewSummary): string | null {\n  if (!view.mine) {\n    return view.ownerName ? `Shared by ${view.ownerName}` : 'Shared with everyone';\n  }\n\n  if (view.personalDefault && view.shared) {\n    return 'Opens by default, shared with everyone';\n  }\n\n  if (view.personalDefault) {\n    return 'Opens by default';\n  }\n\n  return view.shared ? 'Shared with everyone' : null;\n}\n\n// The open row keeps this icon too; its check is drawn beside it.\nfunction viewIcon(view: ReportViewSummary): ReportViewMenuItem['icon'] {\n  if (!view.mine) {\n    return 'people';\n  }\n\n  return view.personalDefault ? 'star' : null;\n}\n\n// The rows that act on the open view; with none open, only Save as new view.\nfunction openViewActions(open: ReportViewSummary | null, edited: boolean, canShare: boolean): ReportViewMenuItem[] {\n  const items: ReportViewMenuItem[] = [];\n\n  if (open?.canChange && edited) {\n    items.push(action('saveChanges', 'Save changes'));\n  }\n\n  items.push(action('saveAsNew', 'Save as new view...'));\n\n  if (open?.canChange) {\n    items.push(action('rename', 'Rename...'));\n  }\n\n  if (open?.mine) {\n    items.push(open.personalDefault\n      ? action('clearDefault', 'Stop opening it by default')\n      : action('setDefault', 'Make it my default'));\n  }\n\n  if (open?.mine && canShare) {\n    items.push(open.shared ? action('unshare', 'Stop sharing') : action('share', 'Share with everyone'));\n  }\n\n  if (open?.canDelete) {\n    items.push(action('delete', 'Delete...'));\n  }\n\n  return items;\n}\n\nfunction action(kind: ReportViewMenuItem['kind'], label: string): ReportViewMenuItem {\n  return { kind, label, disabled: false, tooltip: null, divider: false, viewId: null, open: false, icon: null };\n}\n\n// The same rows, the first with a line above it when `divider` is set.\nfunction withDivider(items: ReportViewMenuItem[], divider: boolean): ReportViewMenuItem[] {\n  return items.map((item, index) => (index === 0 && divider ? { ...item, divider: true } : item));\n}\n"]}

package/esm2022/app/reports/report-viewer-features.mjs

@@ -0,0 +1,42 @@
+// The viewer features this viewer implements: the report GET names them
+// (features=<comma list>), and the server assembles the report for exactly
+// these. A feature joins the list in the change that builds its control, never
+// before: the server sends a group only in a shape the viewer says it can show
+// and clear, and a listed feature without its control would get a filter the
+// viewer can neither show nor clear.
+//
+// scopeFilters needs no control of its own: a scope member is an ordinary
+// filter row on its tile. excludeValues is a select's 'Exclude these' row,
+// numberRange its min/max control, matchAny the report bar's Match select,
+// and pageScope shows a page's groups in the report bar of that page.
+// cascadingOptions narrows a select's list by the other filters of its tile
+// (ReportFilterOptionsService). views is the Views picker in the report's
+// header (ReportViewPickerComponent). drill is a time chart's click down, with
+// the tile header's breadcrumb and its menu's Drill up and Back to top as the
+// way back.
+export const VIEWER_FEATURES = [
+    'scopeFilters',
+    'excludeValues',
+    'numberRange',
+    'matchAny',
+    'pageScope',
+    'cascadingOptions',
+    'views',
+    'drill',
+];
+// The features a report offers on this screen: the ones its server serves
+// (Report.viewerFeatures) that this viewer also implements.
+export function offeredViewerFeatures(served) {
+    return (served ?? []).filter((feature) => VIEWER_FEATURES.includes(feature));
+}
+// Whether a select group offers 'Exclude these': the one rule the report bar,
+// the tile headers and the report settings' default row share. The server
+// must serve excludeValues, and no enabled member may bind several columns
+// (multiColumn), since the server cannot leave values out there (an older
+// server sends no multiColumn, and the toggle shows as before).
+export function offersExclude(group, features) {
+    return group.type === 'select'
+        && !group.multiColumn
+        && (features ?? []).includes('excludeValues');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/reports/services/report-filter-options.service.mjs

@@ -0,0 +1,238 @@
+import { DestroyRef, Injectable, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Subject, defer, of } from 'rxjs';
+import { catchError, filter, map, shareReplay, switchMap, take, tap } from 'rxjs/operators';
+import { ReportData } from '../data/report.data';
+import { isMatchAnyGroup } from '../report-filter-items';
+import { tileDataState, tilePageId, valuesMatchAnyGroupIds } from '../tile-data-state';
+import { reportComponents } from '../values';
+import { ReportFilterStateService } from './report-filter-state.service';
+import * as i0 from "@angular/core";
+// The most picks one request asks names for: the server's option cap.
+const SELECTED_CAP = 500;
+// The options a select group's control offers. When the server serves
+// cascadingOptions, a group's list is narrowed by the other entries of its
+// host tile (the narrowed options POST); otherwise it is the full list (the
+// options GET), fetched once per group while its host stays the same. The
+// host is the member whose list the group shows (optionsHost).
+//
+// A list is replayed while its request's signature holds: the host's entries
+// without the group's own, without a cross-filter entry and, while the
+// groups match 'any', without the other groups this one combines with. A new
+// signature fetches again, and a request still in flight for an older one is
+// dropped (switchMap). fs-filter asks on focus and on each keystroke, so a
+// list is fetched on the first of them after a change and replayed for the
+// rest; typing filters the replayed list in the viewer (matchOptions).
+//
+// Every list and every 'selected' answer teaches label() the names of the
+// values it holds, so a pick the narrowed list leaves out keeps its name.
+//
+// Each load of the report (the first, and every reload after a chat or
+// dialog edit) starts again: no list is replayed and no name is kept from an
+// earlier load, so an edit to a tile's source or to an option's name shows on
+// the next ask, as when every bar build fetched its list.
+export class ReportFilterOptionsService {
+    _reportData = inject(ReportData);
+    _filterState = inject(ReportFilterStateService);
+    _destroyRef = inject(DestroyRef);
+    _streams = new Map();
+    _labels = new Map();
+    // The picks each group has asked names for, so a value the server cannot
+    // name (its entity was deleted) is asked for once, not on every keystroke.
+    _asked = new Map();
+    // The report load the lists and names above belong to (the object init()
+    // last read).
+    _loaded = null;
+    // The options the group's control offers now. Nothing is read or sent
+    // until the list is subscribed to, so the signature is the one of the
+    // moment the control asks.
+    options(group, report) {
+        return defer(() => {
+            const narrowed = !!report?.viewerFeatures?.includes('cascadingOptions');
+            const host = optionsHost(group, narrowed);
+            if (!host || !report) {
+                return of([]);
+            }
+            this._syncLoad();
+            const stream = this._stream(group.id);
+            const seq = this._ask(stream, group, report, host, narrowed);
+            return stream.lists$
+                .pipe(filter((list) => list.seq >= seq), take(1), map((list) => list.options));
+        });
+    }
+    // The name a value of the group was last listed or labeled with in this
+    // load of the report, or null when no list or answer has named it yet.
+    label(groupId, value) {
+        this._syncLoad();
+        return this._labels.get(groupId)?.get(String(value)) ?? null;
+    }
+    // Whether the group's latest list was cut at 500.
+    truncated(groupId) {
+        this._syncLoad();
+        return this._streams.get(groupId)?.truncated ?? false;
+    }
+    // Whether the group's latest request failed. Its list is then empty, and
+    // the next ask fetches again.
+    failed(groupId) {
+        this._syncLoad();
+        return this._streams.get(groupId)?.failed ?? false;
+    }
+    // Sends a request when the signature moved, or when a pick has no name
+    // yet and was never asked for. Returns the number of the request whose
+    // answer the caller takes: the one sent, else the latest.
+    _ask(stream, group, report, host, narrowed) {
+        const body = narrowed ? this._request(group, report, host) : null;
+        // The host member is part of it: a report edit that moves the group's
+        // list to another member or column lists again.
+        const signature = JSON.stringify([host.id, host.filterColumn, body?.filters ?? null, body?.matchAnyGroupIds ?? []]);
+        const unnamed = (body?.selected ?? [])
+            .filter((value) => this.label(group.id, value) === null && !this._askedFor(group.id).has(String(value)));
+        if (signature === stream.signature && !unnamed.length) {
+            return stream.seq;
+        }
+        unnamed.forEach((value) => this._askedFor(group.id).add(String(value)));
+        stream.signature = signature;
+        stream.seq += 1;
+        stream.requests$.next({ seq: stream.seq, fetch: this._fetch(stream, group.id, report.id, host.id, body) });
+        return stream.seq;
+    }
+    // The narrowed request for the group: what its host tile's data request
+    // carries now, minus the entries that must not narrow the group's list.
+    _request(group, report, host) {
+        const tile = reportComponents(report).find((component) => component.id === host.componentId) ?? null;
+        const selected = groupPicks(this._filterState.value(group.id));
+        if (!tile) {
+            return { filters: [], ...(selected.length ? { selected } : {}) };
+        }
+        const snapshot = this._filterState.snapshot();
+        // A group whose only members are inline values lists through a value,
+        // which combines its groups by the tile rule over its own page.
+        const matchAnyGroupIds = tile.type === 'value'
+            ? valuesMatchAnyGroupIds(report, tilePageId(report, tile, snapshot), snapshot)
+            : tileDataState(report, tile, snapshot).matchAnyGroupIds ?? [];
+        // Under 'any' another group this one combines with does not limit which
+        // of its values can show rows, so the list leaves it out.
+        const combined = matchAnyGroupIds.length && isMatchAnyGroup(group, tilePageId(report, tile, snapshot))
+            ? matchAnyGroupIds
+            : [];
+        const groupOf = new Map((tile.filters ?? []).map((member) => [member.id, member.filterGroupId]));
+        const filters = this._filterState.resolveForComponent(tile)
+            .filter((entry) => {
+            const groupId = groupOf.get(entry.filterId) ?? null;
+            return !isCrossEntry(entry) && groupId !== group.id && !combined.includes(groupId);
+        });
+        return {
+            filters,
+            ...(matchAnyGroupIds.length ? { matchAnyGroupIds } : {}),
+            ...(selected.length ? { selected } : {}),
+        };
+    }
+    // One request's answer as a list. A failed request answers an empty list
+    // marked failed, and clears the signature, so the next ask fetches again.
+    _fetch(stream, groupId, reportId, filterId, body) {
+        const seq = stream.seq;
+        // An answer that lands after the report loaded again teaches no name.
+        const loaded = this._filterState.report();
+        const answer$ = body
+            ? this._reportData.filterOptionsNarrowed(reportId, filterId, body)
+            : this._reportData.filterOptions(reportId, filterId)
+                .pipe(map((options) => ({ options, truncated: false, narrowedBy: [], selected: [] })));
+        return answer$
+            .pipe(tap((answer) => {
+            if (this._filterState.report() === loaded) {
+                this._remember(groupId, [...(answer?.options ?? []), ...(answer?.selected ?? [])]);
+            }
+        }), map((answer) => ({
+            seq,
+            truncated: !!answer?.truncated,
+            failed: false,
+            options: (answer?.options ?? []).map((option) => ({ name: option.label, value: option.value })),
+        })), catchError(() => {
+            stream.signature = null;
+            return of({ seq, truncated: false, failed: true, options: [] });
+        }));
+    }
+    // The group's stream, opened on its first ask. It is subscribed to here,
+    // for the life of the report view, so an answer is kept for the next ask
+    // even when the control that asked has moved on. When the view goes, the
+    // stream ends: a request still in flight is dropped, whoever still listens.
+    _stream(groupId) {
+        const existing = this._streams.get(groupId);
+        if (existing) {
+            return existing;
+        }
+        const requests$ = new Subject();
+        const stream = {
+            signature: null,
+            seq: 0,
+            truncated: false,
+            failed: false,
+            requests$,
+            lists$: requests$
+                .pipe(switchMap((request) => request.fetch), tap((list) => {
+                stream.truncated = list.truncated;
+                stream.failed = list.failed;
+            }), takeUntilDestroyed(this._destroyRef), shareReplay({ bufferSize: 1, refCount: false })),
+        };
+        // Ends with the stream, when the view goes.
+        stream.lists$.subscribe();
+        this._streams.set(groupId, stream);
+        return stream;
+    }
+    // A new load of the report (init() read another report object) drops what
+    // the last load learned: every signature, so each list is fetched again on
+    // its next ask, and every name and asked pick.
+    _syncLoad() {
+        const loaded = this._filterState.report();
+        if (loaded === this._loaded) {
+            return;
+        }
+        this._loaded = loaded;
+        this._streams.forEach((stream) => {
+            stream.signature = null;
+        });
+        this._labels.clear();
+        this._asked.clear();
+    }
+    _remember(groupId, options) {
+        const labels = this._labels.get(groupId) ?? new Map();
+        for (const option of options) {
+            if (option && typeof option.label === 'string') {
+                labels.set(String(option.value), option.label);
+            }
+        }
+        this._labels.set(groupId, labels);
+    }
+    _askedFor(groupId) {
+        const asked = this._asked.get(groupId) ?? new Set();
+        this._asked.set(groupId, asked);
+        return asked;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportFilterOptionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportFilterOptionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportFilterOptionsService, decorators: [{
+            type: Injectable
+        }] });
+// The member whose list a group shows. The narrowed POST names the server's
+// host: the first enabled member with options, else the first with options.
+// The options GET keeps its older rule, the first member with options, as
+// loadGroupOptions does, so an older server is asked what it always was.
+function optionsHost(group, narrowed) {
+    const members = (group.filters ?? []).filter((member) => member.hasOptions);
+    return (narrowed ? members.find((member) => member.enabled) : null) ?? members[0] ?? null;
+}
+// A cross-filter entry rides in the same filters array as the group entries
+// and carries its crossFilterId. It never narrows a list: a click is a
+// temporary look, and the chip of the cross-filter already shows it.
+function isCrossEntry(entry) {
+    return 'crossFilterId' in entry;
+}
+// A select group's picks, kept or left out, that a request can name: text
+// and numbers, at most SELECTED_CAP.
+function groupPicks(value) {
+    return [...(value?.values ?? []), ...(value?.excludeValues ?? [])]
+        .filter((pick) => typeof pick === 'string' || typeof pick === 'number')
+        .slice(0, SELECTED_CAP);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-filter-options.service.js","sourceRoot":"","sources":["../../../../../src/app/reports/services/report-filter-options.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, Injectable, inject } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nimport { Observable, Subject, defer, of } from 'rxjs';\nimport { catchError, filter, map, shareReplay, switchMap, take, tap } from 'rxjs/operators';\n\nimport { ReportData } from '../data/report.data';\nimport { ReportFilterOptionPair } from '../interfaces/report-filter-option-pair.interface';\nimport { ReportFilterOptionsAsk } from '../interfaces/report-filter-options-ask.interface';\nimport { ReportFilterOptionsList } from '../interfaces/report-filter-options-list.interface';\nimport { ReportFilterOptionsRequest } from '../interfaces/report-filter-options-request.interface';\nimport { ReportFilterOptionsStream } from '../interfaces/report-filter-options-stream.interface';\nimport { ReportFilterOptions } from '../interfaces/report-filter-options.interface';\nimport {\n  FilterGroupValue, Report, ReportFilter, ReportFilterGroup, ReportFilterOption, ResolvedFilterValue,\n} from '../interfaces/report.interface';\nimport { isMatchAnyGroup } from '../report-filter-items';\nimport { tileDataState, tilePageId, valuesMatchAnyGroupIds } from '../tile-data-state';\nimport { reportComponents } from '../values';\n\nimport { ReportFilterStateService } from './report-filter-state.service';\n\n\n// The most picks one request asks names for: the server's option cap.\nconst SELECTED_CAP = 500;\n\n// The options a select group's control offers. When the server serves\n// cascadingOptions, a group's list is narrowed by the other entries of its\n// host tile (the narrowed options POST); otherwise it is the full list (the\n// options GET), fetched once per group while its host stays the same. The\n// host is the member whose list the group shows (optionsHost).\n//\n// A list is replayed while its request's signature holds: the host's entries\n// without the group's own, without a cross-filter entry and, while the\n// groups match 'any', without the other groups this one combines with. A new\n// signature fetches again, and a request still in flight for an older one is\n// dropped (switchMap). fs-filter asks on focus and on each keystroke, so a\n// list is fetched on the first of them after a change and replayed for the\n// rest; typing filters the replayed list in the viewer (matchOptions).\n//\n// Every list and every 'selected' answer teaches label() the names of the\n// values it holds, so a pick the narrowed list leaves out keeps its name.\n//\n// Each load of the report (the first, and every reload after a chat or\n// dialog edit) starts again: no list is replayed and no name is kept from an\n// earlier load, so an edit to a tile's source or to an option's name shows on\n// the next ask, as when every bar build fetched its list.\n@Injectable()\nexport class ReportFilterOptionsService {\n\n  private _reportData = inject(ReportData);\n  private _filterState = inject(ReportFilterStateService);\n  private _destroyRef = inject(DestroyRef);\n  private _streams = new Map<number, ReportFilterOptionsStream>();\n  private _labels = new Map<number, Map<string, string>>();\n  // The picks each group has asked names for, so a value the server cannot\n  // name (its entity was deleted) is asked for once, not on every keystroke.\n  private _asked = new Map<number, Set<string>>();\n  // The report load the lists and names above belong to (the object init()\n  // last read).\n  private _loaded: Report | null = null;\n\n  // The options the group's control offers now. Nothing is read or sent\n  // until the list is subscribed to, so the signature is the one of the\n  // moment the control asks.\n  public options(group: ReportFilterGroup, report: Report | null): Observable<ReportFilterOptionPair[]> {\n    return defer(() => {\n      const narrowed = !!report?.viewerFeatures?.includes('cascadingOptions');\n      const host = optionsHost(group, narrowed);\n\n      if (!host || !report) {\n        return of([]);\n      }\n\n      this._syncLoad();\n      const stream = this._stream(group.id);\n      const seq = this._ask(stream, group, report, host, narrowed);\n\n      return stream.lists$\n        .pipe(\n          filter((list) => list.seq >= seq),\n          take(1),\n          map((list) => list.options),\n        );\n    });\n  }\n\n  // The name a value of the group was last listed or labeled with in this\n  // load of the report, or null when no list or answer has named it yet.\n  public label(groupId: number, value: unknown): string | null {\n    this._syncLoad();\n\n    return this._labels.get(groupId)?.get(String(value)) ?? null;\n  }\n\n  // Whether the group's latest list was cut at 500.\n  public truncated(groupId: number): boolean {\n    this._syncLoad();\n\n    return this._streams.get(groupId)?.truncated ?? false;\n  }\n\n  // Whether the group's latest request failed. Its list is then empty, and\n  // the next ask fetches again.\n  public failed(groupId: number): boolean {\n    this._syncLoad();\n\n    return this._streams.get(groupId)?.failed ?? false;\n  }\n\n  // Sends a request when the signature moved, or when a pick has no name\n  // yet and was never asked for. Returns the number of the request whose\n  // answer the caller takes: the one sent, else the latest.\n  private _ask(\n    stream: ReportFilterOptionsStream,\n    group: ReportFilterGroup,\n    report: Report,\n    host: ReportFilter,\n    narrowed: boolean,\n  ): number {\n    const body = narrowed ? this._request(group, report, host) : null;\n    // The host member is part of it: a report edit that moves the group's\n    // list to another member or column lists again.\n    const signature = JSON.stringify([host.id, host.filterColumn, body?.filters ?? null, body?.matchAnyGroupIds ?? []]);\n    const unnamed = (body?.selected ?? [])\n      .filter((value) => this.label(group.id, value) === null && !this._askedFor(group.id).has(String(value)));\n\n    if (signature === stream.signature && !unnamed.length) {\n      return stream.seq;\n    }\n\n    unnamed.forEach((value) => this._askedFor(group.id).add(String(value)));\n    stream.signature = signature;\n    stream.seq += 1;\n    stream.requests$.next({ seq: stream.seq, fetch: this._fetch(stream, group.id, report.id, host.id, body) });\n\n    return stream.seq;\n  }\n\n  // The narrowed request for the group: what its host tile's data request\n  // carries now, minus the entries that must not narrow the group's list.\n  private _request(group: ReportFilterGroup, report: Report, host: ReportFilter): ReportFilterOptionsRequest {\n    const tile = reportComponents(report).find((component) => component.id === host.componentId) ?? null;\n    const selected = groupPicks(this._filterState.value(group.id));\n\n    if (!tile) {\n      return { filters: [], ...(selected.length ? { selected } : {}) };\n    }\n\n    const snapshot = this._filterState.snapshot();\n    // A group whose only members are inline values lists through a value,\n    // which combines its groups by the tile rule over its own page.\n    const matchAnyGroupIds = tile.type === 'value'\n      ? valuesMatchAnyGroupIds(report, tilePageId(report, tile, snapshot), snapshot)\n      : tileDataState(report, tile, snapshot).matchAnyGroupIds ?? [];\n    // Under 'any' another group this one combines with does not limit which\n    // of its values can show rows, so the list leaves it out.\n    const combined = matchAnyGroupIds.length && isMatchAnyGroup(group, tilePageId(report, tile, snapshot))\n      ? matchAnyGroupIds\n      : [];\n    const groupOf = new Map((tile.filters ?? []).map((member) => [member.id, member.filterGroupId]));\n    const filters = this._filterState.resolveForComponent(tile)\n      .filter((entry) => {\n        const groupId = groupOf.get(entry.filterId) ?? null;\n\n        return !isCrossEntry(entry) && groupId !== group.id && !combined.includes(groupId);\n      });\n\n    return {\n      filters,\n      ...(matchAnyGroupIds.length ? { matchAnyGroupIds } : {}),\n      ...(selected.length ? { selected } : {}),\n    };\n  }\n\n  // One request's answer as a list. A failed request answers an empty list\n  // marked failed, and clears the signature, so the next ask fetches again.\n  private _fetch(\n    stream: ReportFilterOptionsStream,\n    groupId: number,\n    reportId: number,\n    filterId: number,\n    body: ReportFilterOptionsRequest | null,\n  ): Observable<ReportFilterOptionsList> {\n    const seq = stream.seq;\n    // An answer that lands after the report loaded again teaches no name.\n    const loaded = this._filterState.report();\n    const answer$: Observable<ReportFilterOptions> = body\n      ? this._reportData.filterOptionsNarrowed(reportId, filterId, body)\n      : this._reportData.filterOptions(reportId, filterId)\n        .pipe(map((options: ReportFilterOption[]) => ({ options, truncated: false, narrowedBy: [], selected: [] })));\n\n    return answer$\n      .pipe(\n        tap((answer) => {\n          if (this._filterState.report() === loaded) {\n            this._remember(groupId, [...(answer?.options ?? []), ...(answer?.selected ?? [])]);\n          }\n        }),\n        map((answer) => ({\n          seq,\n          truncated: !!answer?.truncated,\n          failed: false,\n          options: (answer?.options ?? []).map((option) => ({ name: option.label, value: option.value })),\n        })),\n        catchError(() => {\n          stream.signature = null;\n\n          return of({ seq, truncated: false, failed: true, options: [] });\n        }),\n      );\n  }\n\n  // The group's stream, opened on its first ask. It is subscribed to here,\n  // for the life of the report view, so an answer is kept for the next ask\n  // even when the control that asked has moved on. When the view goes, the\n  // stream ends: a request still in flight is dropped, whoever still listens.\n  private _stream(groupId: number): ReportFilterOptionsStream {\n    const existing = this._streams.get(groupId);\n    if (existing) {\n      return existing;\n    }\n\n    const requests$ = new Subject<ReportFilterOptionsAsk>();\n    const stream: ReportFilterOptionsStream = {\n      signature: null,\n      seq: 0,\n      truncated: false,\n      failed: false,\n      requests$,\n      lists$: requests$\n        .pipe(\n          switchMap((request) => request.fetch),\n          tap((list) => {\n            stream.truncated = list.truncated;\n            stream.failed = list.failed;\n          }),\n          takeUntilDestroyed(this._destroyRef),\n          shareReplay({ bufferSize: 1, refCount: false }),\n        ),\n    };\n\n    // Ends with the stream, when the view goes.\n    stream.lists$.subscribe();\n    this._streams.set(groupId, stream);\n\n    return stream;\n  }\n\n  // A new load of the report (init() read another report object) drops what\n  // the last load learned: every signature, so each list is fetched again on\n  // its next ask, and every name and asked pick.\n  private _syncLoad(): void {\n    const loaded = this._filterState.report();\n    if (loaded === this._loaded) {\n      return;\n    }\n\n    this._loaded = loaded;\n    this._streams.forEach((stream) => {\n      stream.signature = null;\n    });\n    this._labels.clear();\n    this._asked.clear();\n  }\n\n  private _remember(groupId: number, options: ReportFilterOption[]): void {\n    const labels = this._labels.get(groupId) ?? new Map<string, string>();\n\n    for (const option of options) {\n      if (option && typeof option.label === 'string') {\n        labels.set(String(option.value), option.label);\n      }\n    }\n\n    this._labels.set(groupId, labels);\n  }\n\n  private _askedFor(groupId: number): Set<string> {\n    const asked = this._asked.get(groupId) ?? new Set<string>();\n    this._asked.set(groupId, asked);\n\n    return asked;\n  }\n}\n\n\n// The member whose list a group shows. The narrowed POST names the server's\n// host: the first enabled member with options, else the first with options.\n// The options GET keeps its older rule, the first member with options, as\n// loadGroupOptions does, so an older server is asked what it always was.\nfunction optionsHost(group: ReportFilterGroup, narrowed: boolean): ReportFilter | null {\n  const members = (group.filters ?? []).filter((member) => member.hasOptions);\n\n  return (narrowed ? members.find((member) => member.enabled) : null) ?? members[0] ?? null;\n}\n\n// A cross-filter entry rides in the same filters array as the group entries\n// and carries its crossFilterId. It never narrows a list: a click is a\n// temporary look, and the chip of the cross-filter already shows it.\nfunction isCrossEntry(entry: ResolvedFilterValue): boolean {\n  return 'crossFilterId' in entry;\n}\n\n// A select group's picks, kept or left out, that a request can name: text\n// and numbers, at most SELECTED_CAP.\nfunction groupPicks(value: FilterGroupValue | undefined): (string | number)[] {\n  return [...(value?.values ?? []), ...(value?.excludeValues ?? [])]\n    .filter((pick): pick is string | number => typeof pick === 'string' || typeof pick === 'number')\n    .slice(0, SELECTED_CAP);\n}\n"]}