@firestitch/report 18.8.1 → 18.10.0

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

@@ -1,6 +1,10 @@
 import { Observable } from 'rxjs';
 import { ReportChatViewerFilter } from '../interfaces/report-chat-viewer-filter.interface';
-import { ChartGranularity, FilterGroupDefault, FilterGroupValue, Report, ReportComponent, ReportFilterGroup, ReportFormatContext, ReportSort, ReportUrlParams, ReportUrlSnapshot, ResolvedFilterValue } from '../interfaces/report.interface';
+import { ReportDrillStep } from '../interfaces/report-drill-step.interface';
+import { ReportFilterMatch } from '../interfaces/report-filter-match.type';
+import { ReportViewConfig } from '../interfaces/report-view-config.interface';
+import { ChartGranularity, FilterGroupDefault, FilterGroupValue, Report, ReportComponent, ReportFilterGroup, ReportFormatContext, ReportRelativeRange, ReportSort, ReportUrlParams, ReportUrlSnapshot, ResolvedFilterValue } from '../interfaces/report.interface';
+import { ComponentDataState } from '../interfaces/report.interface';
 import * as i0 from "@angular/core";
 export declare function sameDefault(a: FilterGroupDefault | null, b: FilterGroupDefault | null): boolean;
 export declare function sameFilterValue(a: FilterGroupValue | null | undefined, b: FilterGroupValue | null | undefined): boolean;
@@ -17,6 +21,15 @@ export declare class ReportFilterStateService {
     readonly timezone: import("@angular/core").WritableSignal<string>;
     readonly formatContext: import("@angular/core").WritableSignal<ReportFormatContext>;
     readonly listHidden: import("@angular/core").WritableSignal<ReadonlyMap<number, readonly string[]>>;
+    readonly stateVersion: import("@angular/core").Signal<number>;
+    readonly appliedVersion: import("@angular/core").Signal<number>;
+    readonly listSortResets: import("@angular/core").Signal<ReadonlyMap<number, number>>;
+    readonly page: import("@angular/core").Signal<number>;
+    readonly match: import("@angular/core").Signal<ReportFilterMatch>;
+    readonly viewerFeatures: import("@angular/core").Signal<import("@firestitch/report").ReportViewerFeature[]>;
+    readonly report: import("@angular/core").Signal<Report>;
+    readonly base: import("@angular/core").Signal<ReportViewConfig>;
+    readonly viewChanged: import("@angular/core").Signal<boolean>;
     private _values;
     private _groups;
     private _sessionDisabled;
@@ -30,6 +43,17 @@ export declare class ReportFilterStateService {
     private _listSearchChanged$;
     private _changed$;
     private _urlChanged$;
+    private _revision;
+    private _stateVersion;
+    private _appliedVersion;
+    private _listSortResets;
+    private _report;
+    private _pageId;
+    private _match;
+    private _drills;
+    private _drillChanged$;
+    private _baseConfig;
+    private _temporary;
     init(report: Report, restore?: ReportUrlParams | null): void;
     value(groupId: number): FilterGroupValue | undefined;
     setValue(groupId: number, value: FilterGroupValue | null): void;
@@ -53,9 +77,27 @@ export declare class ReportFilterStateService {
     isFilterDisabled(filterId: number): boolean;
     toggleFilter(filterId: number, groupId: number): void;
     changesFor(component: ReportComponent): Observable<number | null>;
+    changesForAny(components: () => ReportComponent[]): Observable<number>;
     resolveForComponent(component: ReportComponent): ResolvedFilterValue[];
     viewerFilters(): ReportChatViewerFilter[];
     resolveForReport(report: Report, pageId?: number | null): ResolvedFilterValue[];
+    setPage(pageId: number | null): void;
+    setMatch(match: ReportFilterMatch): void;
+    drill(componentId: number): readonly ReportDrillStep[];
+    setDrill(componentId: number, path: readonly ReportDrillStep[]): void;
+    drillChanges(componentId: number): Observable<void>;
+    adoptDrill(componentId: number, path: readonly ReportDrillStep[]): boolean;
+    snapshot(): ReportViewConfig;
+    authoredConfig(): ReportViewConfig;
+    apply(config: ReportViewConfig | null, urlDiff?: ReportViewConfig | null, base?: ReportViewConfig | null): void;
+    resetToBase(): void;
+    setBaseToScreen(): void;
+    clearBase(): void;
+    resetGroupsToBase(groupIds: readonly number[]): void;
+    groupsDifferFromBase(groupIds: readonly number[]): boolean;
+    rewriteUrl(): void;
+    tileState(component: ReportComponent): ComponentDataState;
+    livePreset(groupId: number): ReportRelativeRange | null;
     private _resolvedFields;
     private _livePreset;
     private _seed;
@@ -68,11 +110,32 @@ export declare class ReportFilterStateService {
     private _prune;
     private _withPreset;
     private _isDefault;
-    private _components;
     private _listComponents;
     private _sortableColumns;
     private _defaultValue;
     private _relativeRange;
+    private _snapshotGroups;
+    private _snapshotTiles;
+    private _setBase;
+    private _applyLayer;
+    private _applyGroups;
+    private _applyGroup;
+    private _rollingValue;
+    private _seedAuthored;
+    private _clearTiles;
+    private _applyTile;
+    private _applyListTile;
+    private _setDrillPath;
+    private _applyPage;
+    private _notifyApplied;
+    private _tiles;
+    private _isChart;
+    private _pruneViewState;
+    private _pruneBase;
+    private _baseTile;
+    private _resolveExcludeAndRange;
+    private _excludeOrRangeDefault;
+    private _countSortResets;
     static ɵfac: i0.ɵɵFactoryDeclaration<ReportFilterStateService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ReportFilterStateService>;
 }

package/app/reports/services/report-view.service.d.ts

@@ -0,0 +1,51 @@
+import { ParamMap, Params } from '@angular/router';
+import { Observable } from 'rxjs';
+import { ReportUrlValueName } from '../interfaces/report-url-value-name.type';
+import { ReportViewCreate } from '../interfaces/report-view-create.interface';
+import { ReportViewDeleted } from '../interfaces/report-view-deleted.interface';
+import { ReportViewSummary } from '../interfaces/report-view-summary.interface';
+import { ReportView } from '../interfaces/report-view.interface';
+import { Report } from '../interfaces/report.interface';
+import * as i0 from "@angular/core";
+export declare class ReportViewService {
+    readonly views: import("@angular/core").Signal<ReportViewSummary[]>;
+    readonly canShare: import("@angular/core").Signal<boolean>;
+    readonly openView: import("@angular/core").Signal<ReportView>;
+    readonly viewChanged: import("@angular/core").Signal<boolean>;
+    private _reportData;
+    private _filterState;
+    private _message;
+    private _destroyRef;
+    private _views;
+    private _canShare;
+    private _openView;
+    private _reportId;
+    private _tooLongShown;
+    serves(report: Report | null): boolean;
+    open(report: Report, params: Params, pageId: number | null): Observable<void>;
+    refresh(report: Report): void;
+    pick(reportViewId: number): Observable<ReportView>;
+    openDefaults(): void;
+    saveAsNew(view: Omit<ReportViewCreate, 'config'>): Observable<ReportView>;
+    saveChanges(): Observable<ReportView>;
+    rename(name: string): Observable<ReportView>;
+    share(shared: boolean): Observable<ReportView>;
+    setDefault(personalDefault: boolean): Observable<ReportView>;
+    deleteOpen(): Observable<ReportViewDeleted>;
+    urlParams(current: ParamMap, name?: ReportUrlValueName): Params;
+    private _start;
+    private _openDefault;
+    private _openLink;
+    private _openOn;
+    private _changeOpen;
+    private _putRow;
+    private _readViews;
+    private _readView;
+    private _linkWrite;
+    private _linkDays;
+    private _groupDays;
+    private _reportGroups;
+    private _authoredSort;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReportViewService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReportViewService>;
+}

package/app/reports/text.d.ts

@@ -1,11 +1,31 @@
 export declare const DEFAULT_TEXT_SIZE = 12;
 export declare const HEADING_TEXT_SIZES: Record<number, number>;
 export declare const DEFAULT_TEXT_COLOR = "#1f2933";
+export declare const TEXT_TABLE_BORDER_COLOR = "#cbd2d9";
+export declare const TEXT_TABLE_BORDER_WIDTH = 0.75;
+export declare const TEXT_TABLE_CELL_PADDING: {
+    vertical: number;
+    horizontal: number;
+};
+export declare const TEXT_TABLE_MARGIN = 4;
+export interface TextValue {
+    name: string;
+    text?: string;
+    loading?: boolean;
+    reads?: string[];
+}
 export interface TextTokenContext {
     pageNumber: number;
     pageName: string;
     reportName: string;
+    values?: Record<string, TextValue>;
+    valuePageId?: number | null;
 }
+export declare const VALUE_TOKEN_PATTERN: RegExp;
+export declare const VALUE_EMPTY_TEXT = "\u2014";
+export declare const VALUE_LOADING_TEXT = "\u2026";
+export declare function valueToken(key: string): string;
+export declare function valueText(value: TextValue | undefined): string;
 export interface TextRun {
     text: string;
     bold?: boolean;
@@ -24,7 +44,37 @@ export interface TextParagraph {
     bullet?: 'bullet' | 'number';
     heading?: number;
 }
+export interface TextTableCell {
+    paragraphs: TextParagraph[];
+    colSpan: number;
+    rowSpan: number;
+    row: number;
+    column: number;
+    align: 'left' | 'center' | 'right' | 'justify';
+    valign?: 'top' | 'middle' | 'bottom';
+    fill?: string;
+}
+export interface TextTableRow {
+    section: 'head' | 'body' | 'foot';
+    cells: TextTableCell[];
+}
+export interface TextTable {
+    rows: TextTableRow[];
+    columns: number;
+}
+export type TextBlock = {
+    kind: 'text';
+    paragraphs: TextParagraph[];
+} | {
+    kind: 'table';
+    table: TextTable;
+};
 export declare function fillTextTokens(html: string, context: TextTokenContext): string;
+export declare function textBlocks(html: string, context: TextTokenContext): TextBlock[];
 export declare function textParagraphs(html: string, context: TextTokenContext): TextParagraph[];
+export declare function blockParagraphs(blocks: TextBlock[]): TextParagraph[];
 export declare function textPlain(html: string, context: TextTokenContext): string;
+export declare function splitAtTables(parent: Node): (Node[] | HTMLTableElement)[];
+export declare function parseTable(element: HTMLTableElement): TextTable;
+export declare function tableGrid(table: TextTable): TextTable;
 export declare function escapeHtml(value: string): string;

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

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

package/app/reports/tile-loads.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+import { TileLoadResult } from './interfaces/tile-load-result.interface';
+export declare const TILE_REFRESH_DEBOUNCE_MS = 300;
+export declare function tileLoads<T>(refresh$: Observable<unknown>, load: () => Observable<T>, version: () => number): Observable<TileLoadResult<T>>;

package/app/reports/values.d.ts

@@ -0,0 +1,17 @@
+import { Report, ReportComponent, ReportFormatContext, ReportPageValue } from './interfaces/report.interface';
+import { TextValue } from './text';
+export declare const NO_VALUE_KEYS: ReadonlySet<string>;
+export declare function valueKeys(html: string | null | undefined): string[];
+export declare function valueKey(component: ReportComponent): string;
+export declare function operandKeys(value: ReportComponent): string[];
+export declare function shownValues(values: ReportComponent[], texts: ReportComponent[]): ReportComponent[];
+export declare function readKeys(shown: Iterable<string>, values: Record<string, TextValue>): Set<string>;
+export declare function textValues(values: ReportComponent[], results: {
+    rows: ReadonlyMap<number, ReportPageValue>;
+} | null, format: ReportFormatContext, loading?: ReadonlySet<number>): Record<string, TextValue>;
+export declare function formatValueText(value: ReportComponent, row: ReportPageValue, layerValues: ReportComponent[], ctx: ReportFormatContext): string;
+export declare function failedValueKeys(values: ReportComponent[], rows: ReadonlyMap<number, ReportPageValue>): string[];
+export declare function sameTextValues(a: Record<string, TextValue> | undefined, b: Record<string, TextValue> | undefined): boolean;
+export declare function reportComponents(report: Report | null): ReportComponent[];
+export declare function layerValueKeys(report: Report | null): Map<number, Set<string>>;
+export declare function isDrawn(component: ReportComponent): boolean;

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

@@ -12,13 +12,13 @@ export declare class FsAiReportComponent {
     readonly pageChanged: import("@angular/core").OutputEmitterRef<number>;
     readonly report: import("@angular/core").WritableSignal<Report>;
     readonly editMode: import("@angular/core").WritableSignal<boolean>;
-    readonly timezoneLabel: import("@angular/core").Signal<string>;
     readonly pageId: import("@angular/core").WritableSignal<number>;
     readonly chatPageId: import("@angular/core").WritableSignal<number>;
     readonly chatRequestData: import("@angular/core").Signal<Record<string, unknown>>;
     readonly reportFilterConfig: import("@angular/core").WritableSignal<FilterConfig>;
     readonly reportHasFilters: import("@angular/core").Signal<boolean>;
     readonly reportFilterKey: import("@angular/core").Signal<string>;
+    readonly viewsServed: import("@angular/core").Signal<boolean>;
     private _split;
     private _chatPanel;
     private _canvas?;
@@ -27,6 +27,8 @@ export declare class FsAiReportComponent {
     private _router;
     private _route;
     private _filterState;
+    private _filterOptions;
+    private _views;
     private _exportService;
     private _collector;
     private _process;
@@ -36,6 +38,7 @@ export declare class FsAiReportComponent {
     private _restoredReportId;
     private _pageReported;
     private _pageWrite$;
+    private readonly _barVersion;
     constructor();
     toggleEditMode(): void;
     get isMasterMode(): boolean;
@@ -55,9 +58,14 @@ export declare class FsAiReportComponent {
     private _pageIdFromUrl;
     private _writeUrl;
     private _loadReport;
+    private _openReport;
+    private _urlParams;
+    private _openAppliedPage;
     private _reportGroups;
     private _buildReportConfig;
+    private _barChanged;
     private _groupByItem;
+    private _matchItem;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsAiReportComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FsAiReportComponent, "fs-ai-report", never, { "reportId": { "alias": "reportId"; "required": false; "isSignal": true; }; "basePath": { "alias": "basePath"; "required": false; "isSignal": true; }; "pageQueryParam": { "alias": "pageQueryParam"; "required": false; "isSignal": true; }; "urlState": { "alias": "urlState"; "required": false; "isSignal": true; }; }, { "deleted": "deleted"; "renamed": "renamed"; "pageChanged": "pageChanged"; }, never, never, true, never>;
 }

package/app/reports/views/report/report.component.d.ts

@@ -17,6 +17,7 @@ export declare class ReportComponent {
     private _reportData;
     private _reportService;
     private _filterState;
+    private _filterOptions;
     private _exportService;
     private _collector;
     private _process;
@@ -24,6 +25,8 @@ export declare class ReportComponent {
     private _dialog;
     private _destroyRef;
     private _zone;
+    private readonly _barVersion;
+    private readonly _pageId;
     constructor();
     fetchReports: (keyword: string) => import("rxjs").Observable<ReportListItem[]>;
     reportChange(report: ReportListItem | null): void;
@@ -34,6 +37,7 @@ export declare class ReportComponent {
     toggleMasterMode(): void;
     reportSettings(): void;
     componentSettings(component: ReportComponentModel): void;
+    onCanvasPageChanged(pageId: number | null): void;
     onCanvasReportChanged(): void;
     exportPowerpoint(): void;
     exportPdf(): void;
@@ -46,7 +50,9 @@ export declare class ReportComponent {
     get reportHasFilters(): boolean;
     get reportFilterKey(): string;
     private _buildReportConfig;
+    private _barChanged;
     private _groupByItem;
+    private _matchItem;
     private _refreshReportName;
     static ɵfac: i0.ɵɵFactoryDeclaration<ReportComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ReportComponent, "ng-component", never, {}, {}, never, never, true, never>;

package/esm2022/app/reports/anchor-at-point.mjs

@@ -0,0 +1,49 @@
+// A menu or popover that opens at a point, not at a control. fs-menu opens
+// at its trigger element, never at an event, so the caller keeps one
+// invisible trigger: a zero-size span inside a positioned container (a tile,
+// a text block), moved to the point just before the menu opens. On a phone
+// fs-menu opens as a bottom sheet and the point does not matter.
+//
+// The page may be zoomed (the canvas scales it, --canvas-zoom): a point in
+// page pixels is converted to the container's own unscaled pixels.
+// Where the anchor goes inside its container, in the container's unscaled
+// pixels: the point's distance from the container's top left corner (both in
+// page pixels), divided by the zoom.
+export function anchorOffset(point, corner, zoom) {
+    const scale = usableZoom(zoom);
+    return {
+        left: (point.x - corner.x) / scale,
+        top: (point.y - corner.y) / scale,
+    };
+}
+// Moves the anchor to the point (in page pixels) inside the element it is
+// positioned against, then opens what it triggers on the next turn: once the
+// move is laid out, and once the click that asked for it is over, so that
+// click does not close it again.
+export function openAtPoint(anchor, point, zoom, open) {
+    const container = anchor.offsetParent ?? anchor.parentElement;
+    const rect = container?.getBoundingClientRect();
+    // An absolute child is placed from inside its container's border, which
+    // the zoom scales too.
+    const corner = rect
+        ? {
+            x: rect.left + window.scrollX + container.clientLeft * usableZoom(zoom),
+            y: rect.top + window.scrollY + container.clientTop * usableZoom(zoom),
+        }
+        : point;
+    const offset = anchorOffset(point, corner, zoom);
+    Object.assign(anchor.style, {
+        position: 'absolute',
+        width: '0',
+        height: '0',
+        pointerEvents: 'none',
+        left: `${offset.left}px`,
+        top: `${offset.top}px`,
+    });
+    setTimeout(open);
+}
+// The zoom, or 1 when it is not a positive number.
+function usableZoom(zoom) {
+    return Number.isFinite(zoom) && zoom > 0 ? zoom : 1;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,25 @@
+// Which page the canvas opens when its report input changes.
+//
+// - The same report with more pages than before: a page was just added in
+//   this tab, so the canvas lands on the last page. The link's page does not
+//   beat it: that is the stale value the host still holds from the URL.
+// - Otherwise the link's (or the open view's) page, when the report has it.
+// - Another report whose link names no page it has opens on its first page:
+//   the old report's page number means nothing there.
+// - The same report keeps the page it shows when the link's page does not
+//   resolve (it may still be loading); an index past the last page falls
+//   back to the first.
+export function canvasLandingPage(input) {
+    const pageCount = input.pageIds.length;
+    const sameReport = input.reportId === input.previousReportId;
+    if (sameReport && input.previousPageCount > 0 && pageCount > input.previousPageCount) {
+        return pageCount - 1;
+    }
+    const linked = input.pageId == null ? -1 : input.pageIds.indexOf(input.pageId);
+    if (linked > -1) {
+        return linked;
+    }
+    const index = sameReport ? input.activePageIndex : 0;
+    return index < pageCount ? index : 0;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FudmFzLWxhbmRpbmctcGFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHAvcmVwb3J0cy9jYW52YXMtbGFuZGluZy1wYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLDZEQUE2RDtBQUM3RCxFQUFFO0FBQ0YsMEVBQTBFO0FBQzFFLDZFQUE2RTtBQUM3RSx3RUFBd0U7QUFDeEUsNEVBQTRFO0FBQzVFLDRFQUE0RTtBQUM1RSxzREFBc0Q7QUFDdEQsMEVBQTBFO0FBQzFFLHlFQUF5RTtBQUN6RSx1QkFBdUI7QUFDdkIsTUFBTSxVQUFVLGlCQUFpQixDQUFDLEtBQXlCO0lBQ3pELE1BQU0sU0FBUyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDO0lBQ3ZDLE1BQU0sVUFBVSxHQUFHLEtBQUssQ0FBQyxRQUFRLEtBQUssS0FBSyxDQUFDLGdCQUFnQixDQUFDO0lBRTdELElBQUksVUFBVSxJQUFJLEtBQUssQ0FBQyxpQkFBaUIsR0FBRyxDQUFDLElBQUksU0FBUyxHQUFHLEtBQUssQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1FBQ3JGLE9BQU8sU0FBUyxHQUFHLENBQUMsQ0FBQztJQUN2QixDQUFDO0lBRUQsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLE1BQU0sSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDL0UsSUFBSSxNQUFNLEdBQUcsQ0FBQyxDQUFDLEVBQUUsQ0FBQztRQUNoQixPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0lBRUQsTUFBTSxLQUFLLEdBQUcsVUFBVSxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFFckQsT0FBTyxLQUFLLEdBQUcsU0FBUyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUN2QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2FudmFzTGFuZGluZ0lucHV0IH0gZnJvbSAnLi9pbnRlcmZhY2VzL2NhbnZhcy1sYW5kaW5nLWlucHV0LmludGVyZmFjZSc7XG5cblxuLy8gV2hpY2ggcGFnZSB0aGUgY2FudmFzIG9wZW5zIHdoZW4gaXRzIHJlcG9ydCBpbnB1dCBjaGFuZ2VzLlxuLy9cbi8vIC0gVGhlIHNhbWUgcmVwb3J0IHdpdGggbW9yZSBwYWdlcyB0aGFuIGJlZm9yZTogYSBwYWdlIHdhcyBqdXN0IGFkZGVkIGluXG4vLyAgIHRoaXMgdGFiLCBzbyB0aGUgY2FudmFzIGxhbmRzIG9uIHRoZSBsYXN0IHBhZ2UuIFRoZSBsaW5rJ3MgcGFnZSBkb2VzIG5vdFxuLy8gICBiZWF0IGl0OiB0aGF0IGlzIHRoZSBzdGFsZSB2YWx1ZSB0aGUgaG9zdCBzdGlsbCBob2xkcyBmcm9tIHRoZSBVUkwuXG4vLyAtIE90aGVyd2lzZSB0aGUgbGluaydzIChvciB0aGUgb3BlbiB2aWV3J3MpIHBhZ2UsIHdoZW4gdGhlIHJlcG9ydCBoYXMgaXQuXG4vLyAtIEFub3RoZXIgcmVwb3J0IHdob3NlIGxpbmsgbmFtZXMgbm8gcGFnZSBpdCBoYXMgb3BlbnMgb24gaXRzIGZpcnN0IHBhZ2U6XG4vLyAgIHRoZSBvbGQgcmVwb3J0J3MgcGFnZSBudW1iZXIgbWVhbnMgbm90aGluZyB0aGVyZS5cbi8vIC0gVGhlIHNhbWUgcmVwb3J0IGtlZXBzIHRoZSBwYWdlIGl0IHNob3dzIHdoZW4gdGhlIGxpbmsncyBwYWdlIGRvZXMgbm90XG4vLyAgIHJlc29sdmUgKGl0IG1heSBzdGlsbCBiZSBsb2FkaW5nKTsgYW4gaW5kZXggcGFzdCB0aGUgbGFzdCBwYWdlIGZhbGxzXG4vLyAgIGJhY2sgdG8gdGhlIGZpcnN0LlxuZXhwb3J0IGZ1bmN0aW9uIGNhbnZhc0xhbmRpbmdQYWdlKGlucHV0OiBDYW52YXNMYW5kaW5nSW5wdXQpOiBudW1iZXIge1xuICBjb25zdCBwYWdlQ291bnQgPSBpbnB1dC5wYWdlSWRzLmxlbmd0aDtcbiAgY29uc3Qgc2FtZVJlcG9ydCA9IGlucHV0LnJlcG9ydElkID09PSBpbnB1dC5wcmV2aW91c1JlcG9ydElkO1xuXG4gIGlmIChzYW1lUmVwb3J0ICYmIGlucHV0LnByZXZpb3VzUGFnZUNvdW50ID4gMCAmJiBwYWdlQ291bnQgPiBpbnB1dC5wcmV2aW91c1BhZ2VDb3VudCkge1xuICAgIHJldHVybiBwYWdlQ291bnQgLSAxO1xuICB9XG5cbiAgY29uc3QgbGlua2VkID0gaW5wdXQucGFnZUlkID09IG51bGwgPyAtMSA6IGlucHV0LnBhZ2VJZHMuaW5kZXhPZihpbnB1dC5wYWdlSWQpO1xuICBpZiAobGlua2VkID4gLTEpIHtcbiAgICByZXR1cm4gbGlua2VkO1xuICB9XG5cbiAgY29uc3QgaW5kZXggPSBzYW1lUmVwb3J0ID8gaW5wdXQuYWN0aXZlUGFnZUluZGV4IDogMDtcblxuICByZXR1cm4gaW5kZXggPCBwYWdlQ291bnQgPyBpbmRleCA6IDA7XG59XG4iXX0=

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

@@ -1,5 +1,6 @@
-import { ChangeDetectionStrategy, Component, computed, inject, input } from '@angular/core';
+import { ChangeDetectionStrategy, Component, NgZone, computed, inject, input, model, output, untracked, } from '@angular/core';
 import { NgxEchartsDirective } from 'ngx-echarts';
+import { chartMarkClick } from '../../mark-click';
 import { buildChartOption } from '../../option-builder';
 import { ReportFilterStateService } from '../../services/report-filter-state.service';
 import { ComponentNoteComponent } from '../component-note/component-note.component';
@@ -11,19 +12,69 @@ import * as i0 from "@angular/core";
 // theme/echarts.ts). The shared note under the plot names the days a
 // comparison compares and why windowed series read as they do; the series'
 // tooltips describe the windows themselves.
+//
+// A click on a mark (a bar, a point or the line, a slice, a step, or a
+// category's empty band) is reported as a ReportMarkClick (markClick); the
+// tile decides what it does. The tile's actions only shape the option: the
+// hand pointer and the tooltip's hint.
 export class ComponentChartComponent {
     component = input.required();
     data = input(null);
+    // Which legend entries are on, by series name. The tile holds it (two-way),
+    // so it outlives this chart and every option: each new option carries it
+    // (legend.selected), because ngx-echarts sets an option with notMerge. A
+    // click on the legend only records it: the chart has already toggled the
+    // series, so the option is not built again for it (untracked).
+    legendSelected = model({});
+    // What a click on the chart's marks does, from the tile (tileMarkActions).
+    actions = input([]);
+    markClick = output();
+    // A click or a tap on the chart that no mark answered (an empty band by
+    // touch, outside the plot, a waterfall's Total): the tile forgets a tap
+    // it was holding, so the next tap on a mark shows its tooltip first.
+    markMiss = output();
     options = computed(() => {
         const data = this.data();
         return data
-            ? buildChartOption(this.component(), data, this._filterState.formatContext())
+            ? buildChartOption(this.component(), data, this._filterState.formatContext(), untracked(this.legendSelected), this.actions())
             : null;
     });
     _chart = null;
+    // The browser event of the last click a mark answered, so the empty-band
+    // handler skips that event.
+    _markEvent = null;
     _filterState = inject(ReportFilterStateService);
+    _zone = inject(NgZone);
     onChartInit(chart) {
         this._chart = chart;
+        // A click in a category's empty band is no element's click: the chart's
+        // drawing surface reports it. ECharts runs it outside Angular, and
+        // before the chart's own click on a mark (ECharts calls its element
+        // handler last), so it waits a microtask: by then a mark has answered
+        // the same click.
+        chart.getZr().on('click', (event) => {
+            queueMicrotask(() => this._zone.run(() => this._onBandClick(event)));
+        });
+    }
+    // ECharts reports every entry of the legend after a click.
+    onLegendSelectChanged(event) {
+        this.legendSelected.set({ ...(event?.selected ?? {}) });
+    }
+    // A click on a series element. A click on a line or an area's line itself
+    // carries no category, so it takes the category whose band it fell in, and
+    // no series id, so it takes the id the option gave that series (a partial
+    // segment's id names the series it continues).
+    onChartClick(params) {
+        this._markEvent = params.event?.event ?? null;
+        if (params.componentType !== 'series') {
+            this.markMiss.emit();
+            return;
+        }
+        const seriesIndex = params.seriesIndex ?? null;
+        const dataIndex = typeof params.dataIndex === 'number'
+            ? params.dataIndex
+            : this._bandIndex(params.event?.offsetX, params.event?.offsetY);
+        this._emit({ seriesIndex, seriesId: params.seriesId ?? this._seriesId(seriesIndex), dataIndex: dataIndex ?? -1 }, params.event?.event);
     }
     // Called by the canvas when the box is resized in edit mode.
     resize() {
@@ -37,14 +88,55 @@ export class ComponentChartComponent {
             backgroundColor: '#ffffff',
         }) ?? null;
     }
+    // A click on the chart that no element answered: the category whose band
+    // it fell in. Outside the plot it is a miss.
+    _onBandClick(event) {
+        if (event.event === this._markEvent) {
+            return;
+        }
+        this._emit({ seriesIndex: null, seriesId: null, dataIndex: this._bandIndex(event.offsetX, event.offsetY) ?? -1 }, event.event);
+    }
+    // The category index under a point of the chart, read off the category
+    // axis (the y axis of a horizontal chart); null outside the plot or on a
+    // chart without one. An axis finder takes the one coordinate along its
+    // axis, not the point.
+    _bandIndex(x, y) {
+        const chart = this._chart;
+        if (!chart || typeof x !== 'number' || typeof y !== 'number' || !chart.containPixel('grid', [x, y])) {
+            return null;
+        }
+        const horizontal = this.component().config?.orientation === 'horizontal';
+        const index = Number(horizontal
+            ? chart.convertFromPixel({ yAxisIndex: 0 }, y)
+            : chart.convertFromPixel({ xAxisIndex: 0 }, x));
+        return Number.isFinite(index) ? Math.round(index) : null;
+    }
+    // The id the option gave a drawn series, by its index.
+    _seriesId(seriesIndex) {
+        const series = this.options()?.series;
+        const id = Array.isArray(series) && seriesIndex !== null ? series[seriesIndex]?.id : null;
+        return id === null || id === undefined ? null : String(id);
+    }
+    _emit(hit, event) {
+        const data = this.data();
+        const click = data
+            ? chartMarkClick(this.component(), data, this._filterState.formatContext(), hit, event)
+            : null;
+        if (click) {
+            this.markClick.emit(click);
+        }
+        else {
+            this.markMiss.emit();
+        }
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ComponentChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.14", type: ComponentChartComponent, isStandalone: true, selector: "app-report-component-chart", inputs: { component: { classPropertyName: "component", publicName: "component", isSignal: true, isRequired: true, transformFunction: null }, data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: "<div\n  class=\"chart-host\"\n  echarts\n  [options]=\"options() ?? {}\"\n  [theme]=\"'report'\"\n  [autoResize]=\"true\"\n  (chartInit)=\"onChartInit($event)\">\n</div>\n<app-report-component-note [data]=\"data()\"></app-report-component-note>\n", styles: [":host{display:flex;flex-direction:column;width:100%;height:100%}.chart-host{flex:1 1 0;width:100%;min-height:0}\n"], dependencies: [{ kind: "component", type: ComponentNoteComponent, selector: "app-report-component-note", inputs: ["data", "windows", "windowDescriptions", "windowNotes"] }, { kind: "directive", type: NgxEchartsDirective, selector: "echarts, [echarts]", inputs: ["options", "theme", "initOpts", "merge", "autoResize", "loading", "loadingType", "loadingOpts"], outputs: ["chartInit", "optionsError", "chartClick", "chartDblClick", "chartMouseDown", "chartMouseMove", "chartMouseUp", "chartMouseOver", "chartMouseOut", "chartGlobalOut", "chartContextMenu", "chartHighlight", "chartDownplay", "chartSelectChanged", "chartLegendSelectChanged", "chartLegendSelected", "chartLegendUnselected", "chartLegendLegendSelectAll", "chartLegendLegendInverseSelect", "chartLegendScroll", "chartDataZoom", "chartDataRangeSelected", "chartGraphRoam", "chartGeoRoam", "chartTreeRoam", "chartTimelineChanged", "chartTimelinePlayChanged", "chartRestore", "chartDataViewChanged", "chartMagicTypeChanged", "chartGeoSelectChanged", "chartGeoSelected", "chartGeoUnselected", "chartAxisAreaSelected", "chartBrush", "chartBrushEnd", "chartBrushSelected", "chartGlobalCursorTaken", "chartRendered", "chartFinished"], exportAs: ["echarts"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.14", type: ComponentChartComponent, isStandalone: true, selector: "app-report-component-chart", inputs: { component: { classPropertyName: "component", publicName: "component", isSignal: true, isRequired: true, transformFunction: null }, data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null }, legendSelected: { classPropertyName: "legendSelected", publicName: "legendSelected", isSignal: true, isRequired: false, transformFunction: null }, actions: { classPropertyName: "actions", publicName: "actions", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { legendSelected: "legendSelectedChange", markClick: "markClick", markMiss: "markMiss" }, ngImport: i0, template: "<div\n  class=\"chart-host\"\n  echarts\n  [options]=\"options() ?? {}\"\n  [theme]=\"'report'\"\n  [autoResize]=\"true\"\n  (chartInit)=\"onChartInit($event)\"\n  (chartClick)=\"onChartClick($event)\"\n  (chartLegendSelectChanged)=\"onLegendSelectChanged($event)\">\n</div>\n<app-report-component-note [data]=\"data()\"></app-report-component-note>\n", styles: [":host{display:flex;flex-direction:column;width:100%;height:100%}.chart-host{flex:1 1 0;width:100%;min-height:0}\n"], dependencies: [{ kind: "component", type: ComponentNoteComponent, selector: "app-report-component-note", inputs: ["data", "windows", "windowDescriptions", "windowNotes"] }, { kind: "directive", type: NgxEchartsDirective, selector: "echarts, [echarts]", inputs: ["options", "theme", "initOpts", "merge", "autoResize", "loading", "loadingType", "loadingOpts"], outputs: ["chartInit", "optionsError", "chartClick", "chartDblClick", "chartMouseDown", "chartMouseMove", "chartMouseUp", "chartMouseOver", "chartMouseOut", "chartGlobalOut", "chartContextMenu", "chartHighlight", "chartDownplay", "chartSelectChanged", "chartLegendSelectChanged", "chartLegendSelected", "chartLegendUnselected", "chartLegendLegendSelectAll", "chartLegendLegendInverseSelect", "chartLegendScroll", "chartDataZoom", "chartDataRangeSelected", "chartGraphRoam", "chartGeoRoam", "chartTreeRoam", "chartTimelineChanged", "chartTimelinePlayChanged", "chartRestore", "chartDataViewChanged", "chartMagicTypeChanged", "chartGeoSelectChanged", "chartGeoSelected", "chartGeoUnselected", "chartAxisAreaSelected", "chartBrush", "chartBrushEnd", "chartBrushSelected", "chartGlobalCursorTaken", "chartRendered", "chartFinished"], exportAs: ["echarts"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ComponentChartComponent, decorators: [{
             type: Component,
             args: [{ selector: 'app-report-component-chart', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
                         ComponentNoteComponent,
                         NgxEchartsDirective,
-                    ], template: "<div\n  class=\"chart-host\"\n  echarts\n  [options]=\"options() ?? {}\"\n  [theme]=\"'report'\"\n  [autoResize]=\"true\"\n  (chartInit)=\"onChartInit($event)\">\n</div>\n<app-report-component-note [data]=\"data()\"></app-report-component-note>\n", styles: [":host{display:flex;flex-direction:column;width:100%;height:100%}.chart-host{flex:1 1 0;width:100%;min-height:0}\n"] }]
+                    ], template: "<div\n  class=\"chart-host\"\n  echarts\n  [options]=\"options() ?? {}\"\n  [theme]=\"'report'\"\n  [autoResize]=\"true\"\n  (chartInit)=\"onChartInit($event)\"\n  (chartClick)=\"onChartClick($event)\"\n  (chartLegendSelectChanged)=\"onLegendSelectChanged($event)\">\n</div>\n<app-report-component-note [data]=\"data()\"></app-report-component-note>\n", styles: [":host{display:flex;flex-direction:column;width:100%;height:100%}.chart-host{flex:1 1 0;width:100%;min-height:0}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-chart.component.js","sourceRoot":"","sources":["../../../../../../src/app/reports/components/component-chart/component-chart.component.ts","../../../../../../src/app/reports/components/component-chart/component-chart.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy, Component, NgZone, computed, inject, input, model, output, untracked,\n} from '@angular/core';\n\nimport type { ECElementEvent, EChartsOption, ECharts, ElementEvent } from 'echarts';\nimport { NgxEchartsDirective } from 'ngx-echarts';\n\nimport { ChartConfig, ComponentData, ReportComponent } from '../../interfaces/report.interface';\nimport { ReportChartHit } from '../../interfaces/report-chart-hit.interface';\nimport { ReportMarkAction } from '../../interfaces/report-mark-action.type';\nimport { ReportMarkClick } from '../../interfaces/report-mark-click.interface';\nimport { ReportMarkEvent } from '../../interfaces/report-mark-event.interface';\nimport { chartMarkClick } from '../../mark-click';\nimport { buildChartOption } from '../../option-builder';\nimport { ReportFilterStateService } from '../../services/report-filter-state.service';\nimport { ComponentNoteComponent } from '../component-note/component-note.component';\n\n\n// ECharts host for a chart component. Pure rendering: the parent owns the\n// data fetch; this maps (component config, rows, the open report's format\n// context) → option and exposes the chart instance for resize + the future\n// image exports (getDataURL needs the canvas renderer registered in\n// theme/echarts.ts). The shared note under the plot names the days a\n// comparison compares and why windowed series read as they do; the series'\n// tooltips describe the windows themselves.\n//\n// A click on a mark (a bar, a point or the line, a slice, a step, or a\n// category's empty band) is reported as a ReportMarkClick (markClick); the\n// tile decides what it does. The tile's actions only shape the option: the\n// hand pointer and the tooltip's hint.\n@Component({\n  selector: 'app-report-component-chart',\n  templateUrl: './component-chart.component.html',\n  styleUrls: ['./component-chart.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    ComponentNoteComponent,\n    NgxEchartsDirective,\n  ],\n})\nexport class ComponentChartComponent {\n\n  public readonly component = input.required<ReportComponent>();\n  public readonly data = input<ComponentData | null>(null);\n  // Which legend entries are on, by series name. The tile holds it (two-way),\n  // so it outlives this chart and every option: each new option carries it\n  // (legend.selected), because ngx-echarts sets an option with notMerge. A\n  // click on the legend only records it: the chart has already toggled the\n  // series, so the option is not built again for it (untracked).\n  public readonly legendSelected = model<Readonly<Record<string, boolean>>>({});\n  // What a click on the chart's marks does, from the tile (tileMarkActions).\n  public readonly actions = input<readonly ReportMarkAction[]>([]);\n\n  public readonly markClick = output<ReportMarkClick>();\n  // A click or a tap on the chart that no mark answered (an empty band by\n  // touch, outside the plot, a waterfall's Total): the tile forgets a tap\n  // it was holding, so the next tap on a mark shows its tooltip first.\n  public readonly markMiss = output<void>();\n\n  public readonly options = computed<EChartsOption | null>(() => {\n    const data = this.data();\n\n    return data\n      ? buildChartOption(\n        this.component(),\n        data,\n        this._filterState.formatContext(),\n        untracked(this.legendSelected),\n        this.actions(),\n      )\n      : null;\n  });\n\n  private _chart: ECharts | null = null;\n  // The browser event of the last click a mark answered, so the empty-band\n  // handler skips that event.\n  private _markEvent: unknown = null;\n  private readonly _filterState = inject(ReportFilterStateService);\n  private readonly _zone = inject(NgZone);\n\n  public onChartInit(chart: ECharts): void {\n    this._chart = chart;\n    // A click in a category's empty band is no element's click: the chart's\n    // drawing surface reports it. ECharts runs it outside Angular, and\n    // before the chart's own click on a mark (ECharts calls its element\n    // handler last), so it waits a microtask: by then a mark has answered\n    // the same click.\n    chart.getZr().on('click', (event: ElementEvent) => {\n      queueMicrotask(() => this._zone.run(() => this._onBandClick(event)));\n    });\n  }\n\n  // ECharts reports every entry of the legend after a click.\n  public onLegendSelectChanged(event: { selected?: Record<string, boolean> } | null): void {\n    this.legendSelected.set({ ...(event?.selected ?? {}) });\n  }\n\n  // A click on a series element. A click on a line or an area's line itself\n  // carries no category, so it takes the category whose band it fell in, and\n  // no series id, so it takes the id the option gave that series (a partial\n  // segment's id names the series it continues).\n  public onChartClick(params: ECElementEvent): void {\n    this._markEvent = params.event?.event ?? null;\n\n    if (params.componentType !== 'series') {\n      this.markMiss.emit();\n\n      return;\n    }\n\n    const seriesIndex = params.seriesIndex ?? null;\n    const dataIndex = typeof params.dataIndex === 'number'\n      ? params.dataIndex\n      : this._bandIndex(params.event?.offsetX, params.event?.offsetY);\n\n    this._emit(\n      { seriesIndex, seriesId: params.seriesId ?? this._seriesId(seriesIndex), dataIndex: dataIndex ?? -1 },\n      params.event?.event,\n    );\n  }\n\n  // Called by the canvas when the box is resized in edit mode.\n  public resize(): void {\n    this._chart?.resize();\n  }\n\n  // High-res image for the (later-phase) PPT/PDF exports.\n  public getDataURL(pixelRatio = 3): string | null {\n    return this._chart?.getDataURL({\n      type: 'png',\n      pixelRatio,\n      backgroundColor: '#ffffff',\n    }) ?? null;\n  }\n\n  // A click on the chart that no element answered: the category whose band\n  // it fell in. Outside the plot it is a miss.\n  private _onBandClick(event: ElementEvent): void {\n    if (event.event === this._markEvent) {\n      return;\n    }\n\n    this._emit(\n      { seriesIndex: null, seriesId: null, dataIndex: this._bandIndex(event.offsetX, event.offsetY) ?? -1 },\n      event.event,\n    );\n  }\n\n  // The category index under a point of the chart, read off the category\n  // axis (the y axis of a horizontal chart); null outside the plot or on a\n  // chart without one. An axis finder takes the one coordinate along its\n  // axis, not the point.\n  private _bandIndex(x: number | undefined, y: number | undefined): number | null {\n    const chart = this._chart;\n\n    if (!chart || typeof x !== 'number' || typeof y !== 'number' || !chart.containPixel('grid', [x, y])) {\n      return null;\n    }\n\n    const horizontal = (this.component().config as ChartConfig)?.orientation === 'horizontal';\n    const index = Number(horizontal\n      ? chart.convertFromPixel({ yAxisIndex: 0 }, y)\n      : chart.convertFromPixel({ xAxisIndex: 0 }, x));\n\n    return Number.isFinite(index) ? Math.round(index) : null;\n  }\n\n  // The id the option gave a drawn series, by its index.\n  private _seriesId(seriesIndex: number | null): string | null {\n    const series = this.options()?.series;\n    const id = Array.isArray(series) && seriesIndex !== null ? series[seriesIndex]?.id : null;\n\n    return id === null || id === undefined ? null : String(id);\n  }\n\n  private _emit(hit: ReportChartHit, event: unknown): void {\n    const data = this.data();\n    const click = data\n      ? chartMarkClick(this.component(), data, this._filterState.formatContext(), hit, event as ReportMarkEvent)\n      : null;\n\n    if (click) {\n      this.markClick.emit(click);\n    } else {\n      this.markMiss.emit();\n    }\n  }\n}\n","<div\n  class=\"chart-host\"\n  echarts\n  [options]=\"options() ?? {}\"\n  [theme]=\"'report'\"\n  [autoResize]=\"true\"\n  (chartInit)=\"onChartInit($event)\"\n  (chartClick)=\"onChartClick($event)\"\n  (chartLegendSelectChanged)=\"onLegendSelectChanged($event)\">\n</div>\n<app-report-component-note [data]=\"data()\"></app-report-component-note>\n"]}