@firestitch/report 18.0.0

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

@@ -0,0 +1,177 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { filter as rxFilter } from 'rxjs/operators';
+import { startOfMonth, startOfQuarter, startOfYear, subDays, subMonths, } from 'date-fns';
+import { dateBoundString } from '../report-filter-items';
+import * as i0 from "@angular/core";
+// Session filter state for the open report. Filter VALUES are never persisted
+// — this service holds them per filter GROUP (the propagation unit), resolves
+// them into per-component member-filter values for each data request, and
+// notifies the components whose groups changed so only they refetch.
+//
+// Also session-scoped: per-filter enable/disable toggles from a component's
+// filter menu (the `enabled` column is the authored default; a viewer's toggle
+// shouldn't write to the report).
+export class ReportFilterStateService {
+    _values = new Map();
+    _groups = new Map();
+    _sessionDisabled = new Set();
+    // The runtime Frequency control: a single session-wide bucket override for all
+    // time-series charts. Unset = each chart uses its authored granularity. Never
+    // persisted (it dies with this report view), and carried in the data request's
+    // `state`, so it propagates through to the PDF/PowerPoint exports too.
+    _frequency = null;
+    _frequencyChanged$ = new Subject();
+    // Emits the group id that changed; components listen filtered to their own
+    // group ids. null = everything changed (re-init).
+    _changed$ = new Subject();
+    // Seed groups + their defaults when a report loads. Existing session values
+    // for still-existing groups survive a structure re-fetch (a chat edit
+    // shouldn't reset the viewer's filters).
+    init(report) {
+        this._groups.clear();
+        const validIds = new Set();
+        for (const group of report.filterGroups ?? []) {
+            this._groups.set(group.id, group);
+            validIds.add(group.id);
+            if (!this._values.has(group.id)) {
+                const defaultValue = this._defaultValue(group);
+                if (defaultValue) {
+                    this._values.set(group.id, defaultValue);
+                }
+            }
+        }
+        for (const groupId of [...this._values.keys()]) {
+            if (!validIds.has(groupId)) {
+                this._values.delete(groupId);
+            }
+        }
+        this._changed$.next(null);
+    }
+    value(groupId) {
+        return this._values.get(groupId);
+    }
+    setValue(groupId, value) {
+        if (value === null) {
+            this._values.delete(groupId);
+        }
+        else {
+            this._values.set(groupId, value);
+        }
+        this._changed$.next(groupId);
+    }
+    // The active Frequency override, or null when the viewer hasn't chosen one.
+    frequency() {
+        return this._frequency;
+    }
+    setFrequency(frequency) {
+        this._frequency = frequency;
+        this._frequencyChanged$.next();
+    }
+    // Fires whenever the Frequency changes — every time-series chart listens so it
+    // refetches and re-buckets (the override isn't scoped to any filter group, so
+    // changesFor() can't carry it).
+    frequencyChanges() {
+        return this._frequencyChanged$.asObservable();
+    }
+    isFilterDisabled(filterId) {
+        return this._sessionDisabled.has(filterId);
+    }
+    toggleFilter(filterId, groupId) {
+        if (this._sessionDisabled.has(filterId)) {
+            this._sessionDisabled.delete(filterId);
+        }
+        else {
+            this._sessionDisabled.add(filterId);
+        }
+        this._changed$.next(groupId);
+    }
+    // Notifications relevant to ONE component: any change to a group one of its
+    // filters belongs to (or a full re-init).
+    changesFor(component) {
+        const groupIds = new Set((component.filters ?? []).map((filter) => filter.filterGroupId));
+        return this._changed$.asObservable()
+            .pipe(rxFilter((groupId) => groupId === null || groupIds.has(groupId)));
+    }
+    // The group values resolved into this component's member-filter values —
+    // what the data request carries. Disabled filters (authored or session) are
+    // skipped entirely.
+    resolveForComponent(component) {
+        const resolved = [];
+        for (const filter of component.filters ?? []) {
+            if (!filter.enabled || this._sessionDisabled.has(filter.id)) {
+                continue;
+            }
+            const value = this._values.get(filter.filterGroupId);
+            if (!value) {
+                continue;
+            }
+            const entry = { filterId: filter.id };
+            if (value.start) {
+                entry.start = dateBoundString(value.start);
+            }
+            if (value.end) {
+                entry.end = dateBoundString(value.end);
+            }
+            if (value.values?.length) {
+                entry.values = value.values;
+            }
+            if (value.value?.trim()) {
+                entry.value = value.value.trim();
+            }
+            if (entry.start || entry.end || entry.values || entry.value) {
+                resolved.push(entry);
+            }
+        }
+        return resolved;
+    }
+    // A group's authored default — relative presets resolve against "now" each
+    // time the report opens, so a saved "last 12 months" stays relative.
+    _defaultValue(group) {
+        const groupDefault = group.config?.default;
+        if (!groupDefault) {
+            return null;
+        }
+        if (groupDefault.relative) {
+            const range = this._relativeRange(groupDefault.relative);
+            return range ? { start: range.start, end: range.end } : null;
+        }
+        if (groupDefault.start || groupDefault.end) {
+            return {
+                start: groupDefault.start ?? null,
+                end: groupDefault.end ?? null,
+            };
+        }
+        return null;
+    }
+    _relativeRange(relative) {
+        const now = new Date();
+        switch (relative) {
+            case 'last7Days':
+                return { start: subDays(now, 7), end: now };
+            case 'last30Days':
+                return { start: subDays(now, 30), end: now };
+            case 'last3Months':
+                return { start: subMonths(now, 3), end: now };
+            case 'last6Months':
+                return { start: subMonths(now, 6), end: now };
+            case 'last12Months':
+                return { start: subMonths(now, 12), end: now };
+            case 'thisMonth':
+                return { start: startOfMonth(now), end: now };
+            case 'thisQuarter':
+                return { start: startOfQuarter(now), end: now };
+            case 'thisYear':
+            case 'yearToDate':
+                return { start: startOfYear(now), end: now };
+            default:
+                return null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportFilterStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportFilterStateService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportFilterStateService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-filter-state.service.js","sourceRoot":"","sources":["../../../../../src/app/reports/services/report-filter-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { Observable, Subject } from 'rxjs';\nimport { filter as rxFilter } from 'rxjs/operators';\n\nimport {\n  startOfMonth, startOfQuarter, startOfYear,\n  subDays, subMonths,\n} from 'date-fns';\n\nimport {\n  ChartGranularity,\n  FilterGroupValue,\n  Report,\n  ReportComponent,\n  ReportFilterGroup,\n  ResolvedFilterValue,\n} from '../interfaces/report.interface';\nimport { dateBoundString } from '../report-filter-items';\n\n\n// Session filter state for the open report. Filter VALUES are never persisted\n// — this service holds them per filter GROUP (the propagation unit), resolves\n// them into per-component member-filter values for each data request, and\n// notifies the components whose groups changed so only they refetch.\n//\n// Also session-scoped: per-filter enable/disable toggles from a component's\n// filter menu (the `enabled` column is the authored default; a viewer's toggle\n// shouldn't write to the report).\n@Injectable()\nexport class ReportFilterStateService {\n\n  private _values = new Map<number, FilterGroupValue>();\n  private _groups = new Map<number, ReportFilterGroup>();\n  private _sessionDisabled = new Set<number>();\n\n  // The runtime Frequency control: a single session-wide bucket override for all\n  // time-series charts. Unset = each chart uses its authored granularity. Never\n  // persisted (it dies with this report view), and carried in the data request's\n  // `state`, so it propagates through to the PDF/PowerPoint exports too.\n  private _frequency: ChartGranularity | null = null;\n  private _frequencyChanged$ = new Subject<void>();\n\n  // Emits the group id that changed; components listen filtered to their own\n  // group ids. null = everything changed (re-init).\n  private _changed$ = new Subject<number | null>();\n\n  // Seed groups + their defaults when a report loads. Existing session values\n  // for still-existing groups survive a structure re-fetch (a chat edit\n  // shouldn't reset the viewer's filters).\n  public init(report: Report): void {\n    this._groups.clear();\n\n    const validIds = new Set<number>();\n    for (const group of report.filterGroups ?? []) {\n      this._groups.set(group.id, group);\n      validIds.add(group.id);\n\n      if (!this._values.has(group.id)) {\n        const defaultValue = this._defaultValue(group);\n        if (defaultValue) {\n          this._values.set(group.id, defaultValue);\n        }\n      }\n    }\n\n    for (const groupId of [...this._values.keys()]) {\n      if (!validIds.has(groupId)) {\n        this._values.delete(groupId);\n      }\n    }\n\n    this._changed$.next(null);\n  }\n\n  public value(groupId: number): FilterGroupValue | undefined {\n    return this._values.get(groupId);\n  }\n\n  public setValue(groupId: number, value: FilterGroupValue | null): void {\n    if (value === null) {\n      this._values.delete(groupId);\n    } else {\n      this._values.set(groupId, value);\n    }\n\n    this._changed$.next(groupId);\n  }\n\n  // The active Frequency override, or null when the viewer hasn't chosen one.\n  public frequency(): ChartGranularity | null {\n    return this._frequency;\n  }\n\n  public setFrequency(frequency: ChartGranularity | null): void {\n    this._frequency = frequency;\n    this._frequencyChanged$.next();\n  }\n\n  // Fires whenever the Frequency changes — every time-series chart listens so it\n  // refetches and re-buckets (the override isn't scoped to any filter group, so\n  // changesFor() can't carry it).\n  public frequencyChanges(): Observable<void> {\n    return this._frequencyChanged$.asObservable();\n  }\n\n  public isFilterDisabled(filterId: number): boolean {\n    return this._sessionDisabled.has(filterId);\n  }\n\n  public toggleFilter(filterId: number, groupId: number): void {\n    if (this._sessionDisabled.has(filterId)) {\n      this._sessionDisabled.delete(filterId);\n    } else {\n      this._sessionDisabled.add(filterId);\n    }\n\n    this._changed$.next(groupId);\n  }\n\n  // Notifications relevant to ONE component: any change to a group one of its\n  // filters belongs to (or a full re-init).\n  public changesFor(component: ReportComponent): Observable<number | null> {\n    const groupIds = new Set((component.filters ?? []).map((filter) => filter.filterGroupId));\n\n    return this._changed$.asObservable()\n      .pipe(\n        rxFilter((groupId) => groupId === null || groupIds.has(groupId)),\n      );\n  }\n\n  // The group values resolved into this component's member-filter values —\n  // what the data request carries. Disabled filters (authored or session) are\n  // skipped entirely.\n  public resolveForComponent(component: ReportComponent): ResolvedFilterValue[] {\n    const resolved: ResolvedFilterValue[] = [];\n\n    for (const filter of component.filters ?? []) {\n      if (!filter.enabled || this._sessionDisabled.has(filter.id)) {\n        continue;\n      }\n\n      const value = this._values.get(filter.filterGroupId);\n      if (!value) {\n        continue;\n      }\n\n      const entry: ResolvedFilterValue = { filterId: filter.id };\n\n      if (value.start) {\n        entry.start = dateBoundString(value.start);\n      }\n      if (value.end) {\n        entry.end = dateBoundString(value.end);\n      }\n      if (value.values?.length) {\n        entry.values = value.values;\n      }\n      if (value.value?.trim()) {\n        entry.value = value.value.trim();\n      }\n\n      if (entry.start || entry.end || entry.values || entry.value) {\n        resolved.push(entry);\n      }\n    }\n\n    return resolved;\n  }\n\n  // A group's authored default — relative presets resolve against \"now\" each\n  // time the report opens, so a saved \"last 12 months\" stays relative.\n  private _defaultValue(group: ReportFilterGroup): FilterGroupValue | null {\n    const groupDefault = group.config?.default;\n    if (!groupDefault) {\n      return null;\n    }\n\n    if (groupDefault.relative) {\n      const range = this._relativeRange(groupDefault.relative);\n\n      return range ? { start: range.start, end: range.end } : null;\n    }\n\n    if (groupDefault.start || groupDefault.end) {\n      return {\n        start: groupDefault.start ?? null,\n        end: groupDefault.end ?? null,\n      };\n    }\n\n    return null;\n  }\n\n  private _relativeRange(relative: string): { start: Date; end: Date } | null {\n    const now = new Date();\n\n    switch (relative) {\n      case 'last7Days':\n        return { start: subDays(now, 7), end: now };\n      case 'last30Days':\n        return { start: subDays(now, 30), end: now };\n      case 'last3Months':\n        return { start: subMonths(now, 3), end: now };\n      case 'last6Months':\n        return { start: subMonths(now, 6), end: now };\n      case 'last12Months':\n        return { start: subMonths(now, 12), end: now };\n      case 'thisMonth':\n        return { start: startOfMonth(now), end: now };\n      case 'thisQuarter':\n        return { start: startOfQuarter(now), end: now };\n      case 'thisYear':\n      case 'yearToDate':\n        return { start: startOfYear(now), end: now };\n      default:\n        return null;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,56 @@
+import { Injectable, inject } from '@angular/core';
+import { BehaviorSubject, of } from 'rxjs';
+import { map, tap } from 'rxjs/operators';
+import { ReportData } from '../data/report.data';
+import * as i0 from "@angular/core";
+// Holds the report list in memory so the picker doesn't hit the API on every
+// focus. Loaded once when the page opens; create/rename/delete keep the cache
+// in sync.
+export class ReportService {
+    _reportData = inject(ReportData);
+    _reports$ = new BehaviorSubject([]);
+    get reports$() {
+        return this._reports$.asObservable();
+    }
+    load() {
+        return this._reportData.reports()
+            .pipe(tap((reports) => this._reports$.next(reports ?? [])));
+    }
+    // Filters the cached list locally — what the autocomplete's [fetch] calls.
+    filter(keyword) {
+        const term = (keyword ?? '').trim().toLowerCase();
+        const reports = this._reports$.getValue();
+        if (!term) {
+            return of(reports);
+        }
+        return of(reports.filter((report) => report.name.toLowerCase().includes(term)));
+    }
+    create(name) {
+        return this._reportData.create(name)
+            .pipe(tap((report) => {
+            this._reports$.next([...this._reports$.getValue(), report]);
+        }));
+    }
+    rename(reportId, name) {
+        return this._reportData.rename(reportId, name)
+            .pipe(tap((report) => {
+            this._reports$.next(this._reports$.getValue()
+                .map((existing) => (existing.id === report.id ? report : existing)));
+        }));
+    }
+    delete(reportId) {
+        return this._reportData.delete(reportId)
+            .pipe(tap(() => {
+            this._reports$.next(this._reports$.getValue().filter((report) => report.id !== reportId));
+        }), map(() => undefined));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/reports/theme/echarts.mjs

@@ -0,0 +1,59 @@
+// Tree-shaken ECharts build for the reports renderer: only the chart types and
+// components the option-builder emits are registered, keeping the lazy chunk
+// lean. Loaded on demand by ngx-echarts via provideEchartsCore — see
+// REPORT_ECHARTS_PROVIDERS in reports-echarts.provider.ts.
+//
+// The canvas renderer (not SVG) is deliberate: chart.getDataURL() needs it for
+// the high-res images the PPT/PDF exports will use.
+import { BarChart, LineChart, PieChart } from 'echarts/charts';
+import { DatasetComponent, GridComponent, LegendComponent, TooltipComponent, } from 'echarts/components';
+import * as echarts from 'echarts/core';
+import { CanvasRenderer } from 'echarts/renderers';
+import { REPORT_CHART_COLORS_CSS } from './palette';
+echarts.use([
+    BarChart,
+    LineChart,
+    PieChart,
+    GridComponent,
+    TooltipComponent,
+    LegendComponent,
+    DatasetComponent,
+    CanvasRenderer,
+]);
+// The house theme — the single place report chart "standards" live (palette,
+// typography, tooltip styling). Polished defaults now; refined in the polish
+// phase.
+echarts.registerTheme('report', {
+    color: REPORT_CHART_COLORS_CSS,
+    textStyle: {
+        fontFamily: 'Roboto, "Helvetica Neue", sans-serif',
+    },
+    title: {
+        textStyle: { color: '#1f2933', fontSize: 14, fontWeight: 600 },
+    },
+    legend: {
+        textStyle: { color: '#52606d', fontSize: 11 },
+    },
+    tooltip: {
+        backgroundColor: 'rgba(31, 41, 51, 0.92)',
+        borderWidth: 0,
+        textStyle: { color: '#fff', fontSize: 12 },
+    },
+    categoryAxis: {
+        axisLine: { lineStyle: { color: '#cbd2d9' } },
+        axisTick: { show: false },
+        axisLabel: { color: '#52606d', fontSize: 11 },
+        splitLine: { show: false },
+    },
+    valueAxis: {
+        axisLine: { show: false },
+        axisLabel: { color: '#52606d', fontSize: 11 },
+        splitLine: { lineStyle: { color: '#e4e7eb' } },
+    },
+    timeAxis: {
+        axisLine: { lineStyle: { color: '#cbd2d9' } },
+        axisLabel: { color: '#52606d', fontSize: 11 },
+    },
+});
+export default echarts;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/reports/theme/palette.mjs

@@ -0,0 +1,10 @@
+// The report chart palette — one definition shared by the ECharts theme (on
+// screen), the PowerPoint export's native chart colors, and the PDF export,
+// so a series keeps its color across every medium.
+export const REPORT_CHART_COLORS = [
+    '4e79a7', 'f28e2b', 'e15759', '76b7b2', '59a14f',
+    'edc948', 'b07aa1', 'ff9da7', '9c755f', 'bab0ac',
+];
+// CSS-hex form for ECharts.
+export const REPORT_CHART_COLORS_CSS = REPORT_CHART_COLORS.map((color) => `#${color}`);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFsZXR0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvcmVwb3J0cy90aGVtZS9wYWxldHRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRFQUE0RTtBQUM1RSw0RUFBNEU7QUFDNUUsbURBQW1EO0FBQ25ELE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHO0lBQ2pDLFFBQVEsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxRQUFRO0lBQ2hELFFBQVEsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxRQUFRO0NBQ2pELENBQUM7QUFFRiw0QkFBNEI7QUFDNUIsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsbUJBQW1CLENBQUMsR0FBRyxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxJQUFJLEtBQUssRUFBRSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBUaGUgcmVwb3J0IGNoYXJ0IHBhbGV0dGUg4oCUIG9uZSBkZWZpbml0aW9uIHNoYXJlZCBieSB0aGUgRUNoYXJ0cyB0aGVtZSAob25cbi8vIHNjcmVlbiksIHRoZSBQb3dlclBvaW50IGV4cG9ydCdzIG5hdGl2ZSBjaGFydCBjb2xvcnMsIGFuZCB0aGUgUERGIGV4cG9ydCxcbi8vIHNvIGEgc2VyaWVzIGtlZXBzIGl0cyBjb2xvciBhY3Jvc3MgZXZlcnkgbWVkaXVtLlxuZXhwb3J0IGNvbnN0IFJFUE9SVF9DSEFSVF9DT0xPUlMgPSBbXG4gICc0ZTc5YTcnLCAnZjI4ZTJiJywgJ2UxNTc1OScsICc3NmI3YjInLCAnNTlhMTRmJyxcbiAgJ2VkYzk0OCcsICdiMDdhYTEnLCAnZmY5ZGE3JywgJzljNzU1ZicsICdiYWIwYWMnLFxuXTtcblxuLy8gQ1NTLWhleCBmb3JtIGZvciBFQ2hhcnRzLlxuZXhwb3J0IGNvbnN0IFJFUE9SVF9DSEFSVF9DT0xPUlNfQ1NTID0gUkVQT1JUX0NIQVJUX0NPTE9SUy5tYXAoKGNvbG9yKSA9PiBgIyR7Y29sb3J9YCk7XG4iXX0=