@firestitch/report 18.0.19 → 18.0.21

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

@@ -1,13 +1,18 @@
 import { RequestConfig } from '@firestitch/api';
 import { Observable } from 'rxjs';
-import { ComponentDataState, FilterGroupDefault, ReportFilterLevel, ResolvedFilterValue } from '../interfaces/report.interface';
+import { ComponentDataState, FilterGroupDefault, ReportFilterLevel, ReportTree, ResolvedFilterValue } from '../interfaces/report.interface';
 import * as i0 from "@angular/core";
 export declare class ReportData<T = any> {
     private _api;
     basePath: string;
     private _path;
     reports(query?: any, config?: RequestConfig): Observable<T>;
-    create(name: string, config?: RequestConfig): Observable<T>;
+    tree(query?: any, config?: RequestConfig): Observable<ReportTree>;
+    create(name: string, reportFolderId?: number, config?: RequestConfig): Observable<T>;
+    moveReport(reportId: number, reportFolderId: number | null, config?: RequestConfig): Observable<T>;
+    createFolder(name: string, parentReportFolderId?: number, config?: RequestConfig): Observable<T>;
+    updateFolder(reportFolderId: number, folder: Record<string, unknown>, config?: RequestConfig): Observable<T>;
+    deleteFolder(reportFolderId: number, config?: RequestConfig): Observable<T>;
     rename(reportId: number, name: string, config?: RequestConfig): Observable<T>;
     update(reportId: number, settings: Record<string, unknown>, config?: RequestConfig): Observable<T>;
     addPage(reportId: number, config?: RequestConfig): Observable<T>;
@@ -27,6 +32,7 @@ export declare class ReportData<T = any> {
     }>)[], config?: RequestConfig): Observable<T>;
     componentData(reportId: number, componentId: number, filters?: ResolvedFilterValue[], state?: ComponentDataState, config?: RequestConfig): Observable<T>;
     exportComponent(reportId: number, componentId: number, filters?: ResolvedFilterValue[], state?: ComponentDataState, config?: RequestConfig): Observable<T>;
+    exportReport(reportId: number, filters?: ResolvedFilterValue[], pageId?: number | null, config?: RequestConfig): Observable<T>;
     filterOptions(reportId: number, filterId: number, config?: RequestConfig): Observable<T>;
     componentColumns(reportId: number, componentId: number, config?: RequestConfig): Observable<T>;
     addFilter(reportId: number, componentId: number, filter: {

package/app/reports/dialogs/report-settings/report-settings.component.d.ts

@@ -23,8 +23,10 @@ interface FilterDefaultRow {
 export declare class ReportSettingsComponent implements OnInit {
     selectedTab: string;
     name: string;
-    pageSize: 'widescreen' | 'letter';
-    pageOrientation: 'landscape' | 'portrait';
+    pageWidth: number;
+    pageHeight: number;
+    readonly pageDimensionMin = 1;
+    readonly pageDimensionMax = 200;
     layout: 'freeform' | 'flow';
     timezone: string;
     headingSize: number;

package/app/reports/interfaces/report.interface.d.ts

@@ -2,8 +2,6 @@ export type ReportLayout = 'freeform' | 'flow';
 export interface Report {
     id: number;
     name: string;
-    pageSize: 'widescreen' | 'letter';
-    pageOrientation: 'landscape' | 'portrait';
     layout: ReportLayout;
     timezone: string | null;
     config: ReportConfig;
@@ -177,11 +175,37 @@ export interface ReportListItem {
     name: string;
     modifyDate: string;
     state?: ReportState;
+    reportFolderId?: number | null;
+}
+export interface ReportFolder {
+    id: number;
+    name: string;
+    parentReportFolderId: number | null;
+}
+export interface ReportTree {
+    reports: ReportListItem[];
+    folders: ReportFolder[];
+}
+export declare enum ReportNodeType {
+    Folder = "folder",
+    Report = "report"
+}
+export interface ReportNode {
+    key: string;
+    id: number;
+    name: string;
+    type: ReportNodeType;
+    children: ReportNode[];
+    report?: ReportListItem;
 }
 export declare enum ReportState {
     Active = "active",
     Deleted = "deleted"
 }
+export declare const ReportStates: {
+    name: string;
+    value: ReportState;
+}[];
 export interface ReportChatResponse {
     reportChanged?: boolean;
     reportRenamed?: boolean;

package/app/reports/layout.d.ts

@@ -9,3 +9,5 @@ export interface ComponentGeometry {
     h: number;
 }
 export declare function pageGeometry(report: Report, page: ReportPage): Map<number, ComponentGeometry>;
+export declare const PAGE_DIMENSION_MIN = 1;
+export declare const PAGE_DIMENSION_MAX = 200;

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

@@ -1,6 +1,8 @@
 import { Observable } from 'rxjs';
-import { ChartGranularity, FilterGroupValue, Report, ReportComponent, ResolvedFilterValue } from '../interfaces/report.interface';
+import { ChartGranularity, FilterGroupDefault, FilterGroupValue, Report, ReportComponent, ReportFilterGroup, ResolvedFilterValue } from '../interfaces/report.interface';
 import * as i0 from "@angular/core";
+export declare function sameDefault(a: FilterGroupDefault | null, b: FilterGroupDefault | null): boolean;
+export declare function defaultSignature(group: ReportFilterGroup): string;
 export declare class ReportFilterStateService {
     private _values;
     private _groups;
@@ -18,6 +20,7 @@ export declare class ReportFilterStateService {
     toggleFilter(filterId: number, groupId: number): void;
     changesFor(component: ReportComponent): Observable<number | null>;
     resolveForComponent(component: ReportComponent): ResolvedFilterValue[];
+    resolveForReport(report: Report, pageId?: number | null): ResolvedFilterValue[];
     private _defaultValue;
     private _relativeRange;
     static ɵfac: i0.ɵɵFactoryDeclaration<ReportFilterStateService, never>;

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

@@ -12,6 +12,7 @@ export declare class FsAiReportComponent {
     reportFilterConfig: FilterConfig;
     private _split;
     private _chatPanel;
+    private _canvas?;
     private _reportData;
     private _filterState;
     private _exportCollector;
@@ -29,6 +30,7 @@ export declare class FsAiReportComponent {
     onCanvasReportChanged(): void;
     exportPowerpoint(): void;
     exportPdf(): void;
+    exportData(thisPage?: boolean): void;
     onChatResponse(response: FsAiChatResponse): void;
     onResizeStart(event: PointerEvent): void;
     private _resizeTo;

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

@@ -10,6 +10,7 @@ export declare class ReportComponent {
     reportFilterConfig: FilterConfig;
     private _split;
     private _chatPanel;
+    private _canvas?;
     readonly introMessage: {
         text: string;
     };
@@ -35,6 +36,7 @@ export declare class ReportComponent {
     onCanvasReportChanged(): void;
     exportPowerpoint(): void;
     exportPdf(): void;
+    exportData(thisPage?: boolean): void;
     onChatResponse(response: FsAiChatResponse): void;
     onResizeStart(event: PointerEvent): void;
     private _resizeTo;

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

@@ -1,25 +1,45 @@
-import { FsListComponent, FsListConfig } from '@firestitch/list';
-import { ReportListItem, ReportState } from '../../interfaces/report.interface';
+import { OnInit } from '@angular/core';
+import { FilterConfig } from '@firestitch/filter';
+import { ITreeConfig } from '@firestitch/tree';
+import { ReportListItem, ReportNode, ReportNodeType } from '../../interfaces/report.interface';
 import * as i0 from "@angular/core";
-export declare class FsAiReportsComponent {
+export declare class FsAiReportsComponent implements OnInit {
+    static readonly EXPAND_LEVEL = 10;
     readonly basePath: import("@angular/core").InputSignal<string>;
     readonly openPattern: import("@angular/core").InputSignal<string>;
     readonly createPattern: import("@angular/core").InputSignal<string>;
-    list: FsListComponent;
-    listConfig: FsListConfig<ReportListItem>;
-    readonly deletedState = ReportState.Deleted;
+    readonly nodes: import("@angular/core").WritableSignal<ReportNode[]>;
+    treeConfig: ITreeConfig<ReportNode[]>;
+    filterConfig: FilterConfig;
+    readonly nodeType: typeof ReportNodeType;
+    private readonly _tree;
     private _reportData;
     private _router;
     private _route;
     private _prompt;
+    private _message;
     private _dialog;
     private _destroyRef;
+    private _query;
     constructor();
+    ngOnInit(): void;
     openLink(report: ReportListItem): unknown[];
+    isDeleted(report: ReportListItem): boolean;
     createReport(): void;
-    private _patternCommands;
     openSettings(): void;
-    private _initListConfig;
+    private _initFilterConfig;
+    private _initTreeConfig;
+    private _isFolderNode;
+    private _isDeletedNode;
+    private _search;
+    private _load;
+    private _buildNodes;
+    private _move;
+    private _createFolder;
+    private _rename;
+    private _delete;
+    private _restore;
+    private _patternCommands;
     static ɵfac: i0.ɵɵFactoryDeclaration<FsAiReportsComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FsAiReportsComponent, "fs-ai-reports", never, { "basePath": { "alias": "basePath"; "required": false; "isSignal": true; }; "openPattern": { "alias": "openPattern"; "required": false; "isSignal": true; }; "createPattern": { "alias": "createPattern"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/esm2022/app/reports/data/report.data.mjs

@@ -20,20 +20,58 @@ export class ReportData {
             ...config,
         });
     }
-    create(name, config = {}) {
-        return this._api.post(this._path(), { name }, {
+    // Both halves of the listing — reports AND the folders they are filed into —
+    // from the one GET. No `key`, because the whole payload is the answer here;
+    // reports() keeps its 'reports' key for callers that only want the flat list.
+    tree(query = {}, config = {}) {
+        return this._api.get(this._path(), query, config);
+    }
+    create(name, reportFolderId = null, config = {}) {
+        return this._api.post(this._path(), { name, reportFolderId }, {
+            key: 'report',
+            ...config,
+        });
+    }
+    // File a report under a folder, or pass null to move it to the root. Sent
+    // explicitly (never omitted) so the backend can tell "move to root" from
+    // "leave the folder alone".
+    moveReport(reportId, reportFolderId, config = {}) {
+        return this._api.put(this._path(`${reportId}`), { reportFolderId }, {
             key: 'report',
             ...config,
         });
     }
+    createFolder(name, parentReportFolderId = null, config = {}) {
+        return this._api.post(this._path('folders'), { name, parentReportFolderId }, {
+            key: 'folder',
+            ...config,
+        });
+    }
+    // Rename and/or move a folder. Only the keys passed are acted on server-side,
+    // so a rename never disturbs the parent and a drag never disturbs the name.
+    updateFolder(reportFolderId, folder, config = {}) {
+        return this._api.put(this._path(`folders/${reportFolderId}`), folder, {
+            key: 'folder',
+            ...config,
+        });
+    }
+    // A real delete — the backend refuses while the folder still holds a
+    // sub-folder or an active report, so there is no undelete counterpart.
+    deleteFolder(reportFolderId, config = {}) {
+        return this._api.delete(this._path(`folders/${reportFolderId}`), {}, {
+            key: 'folder',
+            ...config,
+        });
+    }
     rename(reportId, name, config = {}) {
         return this._api.put(this._path(`${reportId}`), { name }, {
             key: 'report',
             ...config,
         });
     }
-    // Report settings: any subset of { name, pageSize, pageOrientation, layout,
+    // Report settings: any subset of { name, pageWidth, pageHeight, layout,
     // styles } — styles carry the report's typographic config (e.g. heading size).
+    // The page size is in inches and width/height go together.
     update(reportId, settings, config = {}) {
         return this._api.put(this._path(`${reportId}`), settings, {
             key: 'report',
@@ -105,6 +143,17 @@ export class ReportData {
             ...config,
         });
     }
+    // Exports EVERY component on the report — or on one page — server-side and
+    // resolves to a presigned URL for a zip of one CSV per component, foldered by
+    // page. `filters` carries the resolved values for every component together;
+    // each one picks out its own. Same keep-alive contract as exportComponent,
+    // over a longer run; consume through FsProcess.download.
+    exportReport(reportId, filters = [], pageId = null, config = {}) {
+        return this._api.post(this._path(`${reportId}/export`), { filters, ...(pageId ? { pageId } : {}) }, {
+            key: 'url',
+            ...config,
+        });
+    }
     // Distinct options for a select filter (drives multiselect controls).
     filterOptions(reportId, filterId, config = {}) {
         return this._api.get(this._path(`${reportId}/filters/${filterId}/options`), {}, {
@@ -228,4 +277,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report.data.js","sourceRoot":"","sources":["../../../../../src/app/reports/data/report.data.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\n\nimport { FsApi, RequestConfig } from '@firestitch/api';\n\nimport { Observable } from 'rxjs';\n\nimport {\n  ComponentDataState,\n  FilterGroupDefault,\n  ReportFilterLevel,\n  ResolvedFilterValue,\n} from '../interfaces/report.interface';\n\n\n// API gateway for the Reports module. Every endpoint hangs off [basePath],\n// which defaults to \"reports\" (the framework reports backend at /api/reports)\n// and can be repointed by the host so the package stays self-contained and portable.\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReportData<T = any> {\n  private _api = inject(FsApi);\n\n  // The API root for every reports endpoint. Defaults to the framework reports\n  // context; set it once (e.g. from the host's report page) to mount elsewhere.\n  public basePath = 'reports';\n\n  // Build an endpoint path under the configured base, e.g. _path() => \"ai/reports\",\n  // _path(`${id}/pages`) => \"ai/reports/123/pages\".\n  private _path(suffix = ''): string {\n    return suffix ? `${this.basePath}/${suffix}` : this.basePath;\n  }\n\n  public reports(query: any = {}, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(),\n      query,\n      {\n        key: 'reports',\n        ...config,\n      },\n    );\n  }\n\n  public create(name: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(),\n      { name },\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  public rename(reportId: number, name: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}`),\n      { name },\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Report settings: any subset of { name, pageSize, pageOrientation, layout,\n  // styles } — styles carry the report's typographic config (e.g. heading size).\n  public update(reportId: number, settings: Record<string, unknown>, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}`),\n      settings,\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Append a blank page to the report; resolves to the new page.\n  public addPage(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/pages`),\n      {},\n      {\n        key: 'page',\n        ...config,\n      },\n    );\n  }\n\n  // Component settings: any subset of { title, padding } — the human-facing\n  // dialog edits; geometry (x/y/w/h/flowWidth) is persisted via savePositions\n  // from the canvas instead.\n  public updateComponent(\n    reportId: number,\n    componentId: number,\n    settings: Record<string, unknown>,\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/components/${componentId}/settings`),\n      settings,\n      {\n        key: 'component',\n        ...config,\n      },\n    );\n  }\n\n  // Soft-delete: the report leaves the listing but keeps its pages and\n  // components, so undelete() brings back the same document.\n  public delete(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.delete(\n      this._path(`${reportId}`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Restore a soft-deleted report through its own action endpoint — the report\n  // PUT does not accept `state`.\n  public undelete(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/undelete`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // The assembled structure: pages → components (+ their filters) and the\n  // report's filter groups.\n  public get(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Persist geometry for the moved components only — any subset of\n  // { x, y, w, h } (inches), flowWidth (percent) and order (flow position).\n  public savePositions(\n    reportId: number,\n    positions: ({ componentId: number } & Partial<{ x: number; y: number; w: number; h: number; flowWidth: number; order: number }>)[],\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/components/positions`),\n      { positions },\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // One component's data. The body carries everything session-scoped: the\n  // resolved filter values and the component's own interaction state.\n  public componentData(\n    reportId: number,\n    componentId: number,\n    filters: ResolvedFilterValue[] = [],\n    state: ComponentDataState = {},\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/data`),\n      { filters, state },\n      {\n        key: 'data',\n        ...config,\n      },\n    );\n  }\n\n  // Exports the component's FULL filtered dataset to CSV server-side and\n  // resolves to a presigned download URL. The backend streams percentage\n  // progress while chunking; consume through FsProcess.download.\n  public exportComponent(\n    reportId: number,\n    componentId: number,\n    filters: ResolvedFilterValue[] = [],\n    state: ComponentDataState = {},\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/export`),\n      { filters, state },\n      {\n        key: 'url',\n        ...config,\n      },\n    );\n  }\n\n  // Distinct options for a select filter (drives multiselect controls).\n  public filterOptions(reportId: number, filterId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}/filters/${filterId}/options`),\n      {},\n      {\n        key: 'options',\n        ...config,\n      },\n    );\n  }\n\n  // The component SQL's filterable output columns — drives the column picker\n  // in the filter UI so a column name is never typed by hand.\n  public componentColumns(reportId: number, componentId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}/components/${componentId}/columns`),\n      {},\n      {\n        key: 'columns',\n        ...config,\n      },\n    );\n  }\n\n  // Make one column filterable. `level` (component | report) places a new\n  // group; `groupId` instead links into an existing group. A select filter's\n  // options are derived from the component SQL when optionsSql is omitted.\n  public addFilter(\n    reportId: number,\n    componentId: number,\n    filter: { filterColumn: string; type?: string; label?: string; level?: string; optionsSql?: string; groupId?: number },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/filters`),\n      filter,\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // Update a filter — any subset of { label, optionsSql, enabled }.\n  public updateFilter(\n    reportId: number,\n    filterId: number,\n    changes: { label?: string; optionsSql?: string; enabled?: boolean },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/filters/${filterId}`),\n      changes,\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // Remove a filter (its group goes too when nothing else uses it).\n  public deleteFilter(reportId: number, filterId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.delete(\n      this._path(`${reportId}/filters/${filterId}`),\n      {},\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // The global AI knowledge document (operator-authored agent instructions)\n  // and its full version history: { instructions, versions }.\n  public instructions(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('instructions'),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Save a new version of the document (append-only; an unchanged save is a\n  // no-op server-side). Resolves to the same { instructions, versions } shape.\n  public saveInstructions(content: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path('instructions'),\n      { content },\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Make an earlier version of the document current (no new row is created).\n  public restoreInstruction(instructionId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`instructions/${instructionId}/restore`),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Run a semantic-database build, streamed: emits an event per NDJSON frame\n  // ({ kind: 'log', line, percent } feed lines and { kind: 'section' } phase\n  // markers) and completes when the build ends. Feed the lines into FsProcess.\n  public semanticBuild(config: RequestConfig = {}): Observable<any> {\n    return this._api.stream(\n      'POST',\n      this._path('semantic/build'),\n      { stream: true },\n      config,\n    );\n  }\n\n  // Latest build status + entity scoreboard: { build, detail }.\n  public semanticBuildStatus(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('semantic/build'),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Stop the running build (the current semantic database stays in place).\n  public semanticBuildStop(config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path('semantic/build/stop'),\n      {},\n      {\n        key: 'build',\n        ...config,\n      },\n    );\n  }\n\n  // One entity's cached AI-classified code functions — loaded on expand, one\n  // entity at a time, because the full set across all entities is far too big\n  // to ship inside the scoreboard call.\n  public semanticEntityFunctions(entity: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`semantic/entities/${entity}/functions`),\n      {},\n      {\n        key: 'entityFunctions',\n        ...config,\n      },\n    );\n  }\n\n  // The report module's General settings (semantic-build concurrency + its bounds).\n  public settings(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('settings'),\n      {},\n      {\n        key: 'settings',\n        ...config,\n      },\n    );\n  }\n\n  // Save the General settings; resolves to the same { settings } shape.\n  public saveSettings(settings: { semanticBuildConcurrency: number }, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path('settings'),\n      settings,\n      {\n        key: 'settings',\n        ...config,\n      },\n    );\n  }\n\n  // Update a filter group — its exposure level ('component' | 'report' | 'both')\n  // and/or its default value (the value seeding the report bar on open). Send\n  // `default: null` (or an empty default) to clear it. Only the keys provided\n  // are changed.\n  public updateFilterGroup(\n    reportId: number,\n    groupId: number,\n    changes: { level?: ReportFilterLevel; default?: FilterGroupDefault | null },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/filtergroups/${groupId}`),\n      changes,\n      {\n        key: 'filterGroup',\n        ...config,\n      },\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report.data.js","sourceRoot":"","sources":["../../../../../src/app/reports/data/report.data.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\n\nimport { FsApi, RequestConfig } from '@firestitch/api';\n\nimport { Observable } from 'rxjs';\n\nimport {\n  ComponentDataState,\n  FilterGroupDefault,\n  ReportFilterLevel,\n  ReportTree,\n  ResolvedFilterValue,\n} from '../interfaces/report.interface';\n\n\n// API gateway for the Reports module. Every endpoint hangs off [basePath],\n// which defaults to \"reports\" (the framework reports backend at /api/reports)\n// and can be repointed by the host so the package stays self-contained and portable.\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReportData<T = any> {\n  private _api = inject(FsApi);\n\n  // The API root for every reports endpoint. Defaults to the framework reports\n  // context; set it once (e.g. from the host's report page) to mount elsewhere.\n  public basePath = 'reports';\n\n  // Build an endpoint path under the configured base, e.g. _path() => \"ai/reports\",\n  // _path(`${id}/pages`) => \"ai/reports/123/pages\".\n  private _path(suffix = ''): string {\n    return suffix ? `${this.basePath}/${suffix}` : this.basePath;\n  }\n\n  public reports(query: any = {}, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(),\n      query,\n      {\n        key: 'reports',\n        ...config,\n      },\n    );\n  }\n\n  // Both halves of the listing — reports AND the folders they are filed into —\n  // from the one GET. No `key`, because the whole payload is the answer here;\n  // reports() keeps its 'reports' key for callers that only want the flat list.\n  public tree(query: any = {}, config: RequestConfig = {}): Observable<ReportTree> {\n    return this._api.get(\n      this._path(),\n      query,\n      config,\n    );\n  }\n\n  public create(name: string, reportFolderId: number = null, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(),\n      { name, reportFolderId },\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // File a report under a folder, or pass null to move it to the root. Sent\n  // explicitly (never omitted) so the backend can tell \"move to root\" from\n  // \"leave the folder alone\".\n  public moveReport(reportId: number, reportFolderId: number | null, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}`),\n      { reportFolderId },\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  public createFolder(\n    name: string,\n    parentReportFolderId: number = null,\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path('folders'),\n      { name, parentReportFolderId },\n      {\n        key: 'folder',\n        ...config,\n      },\n    );\n  }\n\n  // Rename and/or move a folder. Only the keys passed are acted on server-side,\n  // so a rename never disturbs the parent and a drag never disturbs the name.\n  public updateFolder(\n    reportFolderId: number,\n    folder: Record<string, unknown>,\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`folders/${reportFolderId}`),\n      folder,\n      {\n        key: 'folder',\n        ...config,\n      },\n    );\n  }\n\n  // A real delete — the backend refuses while the folder still holds a\n  // sub-folder or an active report, so there is no undelete counterpart.\n  public deleteFolder(reportFolderId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.delete(\n      this._path(`folders/${reportFolderId}`),\n      {},\n      {\n        key: 'folder',\n        ...config,\n      },\n    );\n  }\n\n  public rename(reportId: number, name: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}`),\n      { name },\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Report settings: any subset of { name, pageWidth, pageHeight, layout,\n  // styles } — styles carry the report's typographic config (e.g. heading size).\n  // The page size is in inches and width/height go together.\n  public update(reportId: number, settings: Record<string, unknown>, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}`),\n      settings,\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Append a blank page to the report; resolves to the new page.\n  public addPage(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/pages`),\n      {},\n      {\n        key: 'page',\n        ...config,\n      },\n    );\n  }\n\n  // Component settings: any subset of { title, padding } — the human-facing\n  // dialog edits; geometry (x/y/w/h/flowWidth) is persisted via savePositions\n  // from the canvas instead.\n  public updateComponent(\n    reportId: number,\n    componentId: number,\n    settings: Record<string, unknown>,\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/components/${componentId}/settings`),\n      settings,\n      {\n        key: 'component',\n        ...config,\n      },\n    );\n  }\n\n  // Soft-delete: the report leaves the listing but keeps its pages and\n  // components, so undelete() brings back the same document.\n  public delete(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.delete(\n      this._path(`${reportId}`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Restore a soft-deleted report through its own action endpoint — the report\n  // PUT does not accept `state`.\n  public undelete(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/undelete`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // The assembled structure: pages → components (+ their filters) and the\n  // report's filter groups.\n  public get(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Persist geometry for the moved components only — any subset of\n  // { x, y, w, h } (inches), flowWidth (percent) and order (flow position).\n  public savePositions(\n    reportId: number,\n    positions: ({ componentId: number } & Partial<{ x: number; y: number; w: number; h: number; flowWidth: number; order: number }>)[],\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/components/positions`),\n      { positions },\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // One component's data. The body carries everything session-scoped: the\n  // resolved filter values and the component's own interaction state.\n  public componentData(\n    reportId: number,\n    componentId: number,\n    filters: ResolvedFilterValue[] = [],\n    state: ComponentDataState = {},\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/data`),\n      { filters, state },\n      {\n        key: 'data',\n        ...config,\n      },\n    );\n  }\n\n  // Exports the component's FULL filtered dataset to CSV server-side and\n  // resolves to a presigned download URL. The backend streams percentage\n  // progress while chunking; consume through FsProcess.download.\n  public exportComponent(\n    reportId: number,\n    componentId: number,\n    filters: ResolvedFilterValue[] = [],\n    state: ComponentDataState = {},\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/export`),\n      { filters, state },\n      {\n        key: 'url',\n        ...config,\n      },\n    );\n  }\n\n  // Exports EVERY component on the report — or on one page — server-side and\n  // resolves to a presigned URL for a zip of one CSV per component, foldered by\n  // page. `filters` carries the resolved values for every component together;\n  // each one picks out its own. Same keep-alive contract as exportComponent,\n  // over a longer run; consume through FsProcess.download.\n  public exportReport(\n    reportId: number,\n    filters: ResolvedFilterValue[] = [],\n    pageId: number | null = null,\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/export`),\n      { filters, ...(pageId ? { pageId } : {}) },\n      {\n        key: 'url',\n        ...config,\n      },\n    );\n  }\n\n  // Distinct options for a select filter (drives multiselect controls).\n  public filterOptions(reportId: number, filterId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}/filters/${filterId}/options`),\n      {},\n      {\n        key: 'options',\n        ...config,\n      },\n    );\n  }\n\n  // The component SQL's filterable output columns — drives the column picker\n  // in the filter UI so a column name is never typed by hand.\n  public componentColumns(reportId: number, componentId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}/components/${componentId}/columns`),\n      {},\n      {\n        key: 'columns',\n        ...config,\n      },\n    );\n  }\n\n  // Make one column filterable. `level` (component | report) places a new\n  // group; `groupId` instead links into an existing group. A select filter's\n  // options are derived from the component SQL when optionsSql is omitted.\n  public addFilter(\n    reportId: number,\n    componentId: number,\n    filter: { filterColumn: string; type?: string; label?: string; level?: string; optionsSql?: string; groupId?: number },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/filters`),\n      filter,\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // Update a filter — any subset of { label, optionsSql, enabled }.\n  public updateFilter(\n    reportId: number,\n    filterId: number,\n    changes: { label?: string; optionsSql?: string; enabled?: boolean },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/filters/${filterId}`),\n      changes,\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // Remove a filter (its group goes too when nothing else uses it).\n  public deleteFilter(reportId: number, filterId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.delete(\n      this._path(`${reportId}/filters/${filterId}`),\n      {},\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // The global AI knowledge document (operator-authored agent instructions)\n  // and its full version history: { instructions, versions }.\n  public instructions(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('instructions'),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Save a new version of the document (append-only; an unchanged save is a\n  // no-op server-side). Resolves to the same { instructions, versions } shape.\n  public saveInstructions(content: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path('instructions'),\n      { content },\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Make an earlier version of the document current (no new row is created).\n  public restoreInstruction(instructionId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`instructions/${instructionId}/restore`),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Run a semantic-database build, streamed: emits an event per NDJSON frame\n  // ({ kind: 'log', line, percent } feed lines and { kind: 'section' } phase\n  // markers) and completes when the build ends. Feed the lines into FsProcess.\n  public semanticBuild(config: RequestConfig = {}): Observable<any> {\n    return this._api.stream(\n      'POST',\n      this._path('semantic/build'),\n      { stream: true },\n      config,\n    );\n  }\n\n  // Latest build status + entity scoreboard: { build, detail }.\n  public semanticBuildStatus(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('semantic/build'),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Stop the running build (the current semantic database stays in place).\n  public semanticBuildStop(config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path('semantic/build/stop'),\n      {},\n      {\n        key: 'build',\n        ...config,\n      },\n    );\n  }\n\n  // One entity's cached AI-classified code functions — loaded on expand, one\n  // entity at a time, because the full set across all entities is far too big\n  // to ship inside the scoreboard call.\n  public semanticEntityFunctions(entity: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`semantic/entities/${entity}/functions`),\n      {},\n      {\n        key: 'entityFunctions',\n        ...config,\n      },\n    );\n  }\n\n  // The report module's General settings (semantic-build concurrency + its bounds).\n  public settings(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('settings'),\n      {},\n      {\n        key: 'settings',\n        ...config,\n      },\n    );\n  }\n\n  // Save the General settings; resolves to the same { settings } shape.\n  public saveSettings(settings: { semanticBuildConcurrency: number }, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path('settings'),\n      settings,\n      {\n        key: 'settings',\n        ...config,\n      },\n    );\n  }\n\n  // Update a filter group — its exposure level ('component' | 'report' | 'both')\n  // and/or its default value (the value seeding the report bar on open). Send\n  // `default: null` (or an empty default) to clear it. Only the keys provided\n  // are changed.\n  public updateFilterGroup(\n    reportId: number,\n    groupId: number,\n    changes: { level?: ReportFilterLevel; default?: FilterGroupDefault | null },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/filtergroups/${groupId}`),\n      changes,\n      {\n        key: 'filterGroup',\n        ...config,\n      },\n    );\n  }\n}\n"]}