@firestitch/report 18.7.0 → 18.8.1

package/esm2022/app/reports/output-notes.mjs

@@ -0,0 +1,204 @@
+import { comparisonNoteText, comparisonOffsetLabel, formatDayRange, formatDayWindow, formatReadingDay, isReadOnOneDay, kpiNoteText, windowNoteText, windowText, } from './format';
+// Between the current window and each prior one on the windows line.
+const WINDOWS_SEPARATOR = ' · ';
+// Ranks and shares are computed after the viewer's filters, never before.
+const FILTERED_ROWS_SENTENCE = 'Computed over the rows the filters keep.';
+const ROLE_LEADS = {
+    current: 'Value',
+    prior: 'Prior value',
+    change: 'Change',
+    percent_change: 'Percent change',
+};
+// The note's lines, in order: the windows, then the comparison's notes and a
+// KPI's delta note, then the windowed values' descriptions and notes. A line is never repeated (two
+// windowed values often share a note). Empty when the data has none of the
+// keys, or none of the parts asked for.
+export function componentNoteLines(data, context, parts = {}) {
+    if (!data) {
+        return [];
+    }
+    const lines = [
+        parts.windows === false ? '' : componentWindowsLine(data, context),
+        ...comparisonNotes(data.comparison),
+        kpiNote(data.kpi, data.comparison),
+        ...(parts.windowDescriptions ? windowDescriptions(data, context.locale) : []),
+        ...(parts.windowNotes === false ? [] : windowNotes(data, context.locale)),
+    ];
+    return [...new Set(lines.filter((line) => !!line))];
+}
+// What one output column holds, for its header's tooltip: the windows a
+// compared value covers, a rank's or a share's scope, and how a windowed value
+// was computed. A cross-tab cell column reads its measure's meaning through
+// cellMeasures. '' for a plain column.
+export function outputColumnNote(column, data, locale) {
+    const alias = data?.cellMeasures?.[column] ?? column;
+    const output = data?.outputs?.[alias];
+    if (!output) {
+        return '';
+    }
+    return [
+        comparisonSentence(output, data.comparison, locale),
+        rankSentence(output, data.outputs),
+        shareSentence(output, data.outputs),
+        windowSentences(data.windows?.[alias], locale, data),
+    ]
+        .filter((sentence) => !!sentence)
+        .join(' ');
+}
+// 'Sep 1 – 15, 2026 · vs previous month: Aug 1 – 15, 2026'. A comparison
+// with no current window yet has no line (its no_window note says so); a
+// component without a comparison shows its timeframe's days. '' when the data
+// has neither. The note's first line, and the PDF and PowerPoint exports'
+// subtitle under a chart's or a list's title.
+export function componentWindowsLine(data, context) {
+    const comparison = data.comparison;
+    if (comparison) {
+        return comparison.current ? comparisonWindowsLine(comparison, comparison.current, context.locale) : '';
+    }
+    return data.timeframe ? formatDayWindow(data.timeframe, context.timezone, context.locale) : '';
+}
+// Read on one day, the line names the days the values are read on: 'On Sep
+// 15, 2026 · vs previous month: Aug 31, 2026'.
+function comparisonWindowsLine(comparison, currentWindow, locale) {
+    if (isReadOnOneDay(comparison)) {
+        const priors = (comparison.offsets ?? []).map((offset, index) => {
+            const prior = comparison.priors?.[index];
+            const day = prior ? formatDayRange(prior.end, prior.end, locale) : '';
+            return day ? `${comparisonOffsetLabel(offset)}: ${day}` : comparisonOffsetLabel(offset);
+        });
+        return [formatReadingDay(currentWindow, locale, true), ...priors]
+            .filter((part) => !!part)
+            .join(WINDOWS_SEPARATOR);
+    }
+    const current = formatDayWindow(currentWindow, comparison.timezone, locale);
+    const priors = (comparison.offsets ?? []).map((offset, index) => {
+        return priorWindowText(offset, comparison.priors?.[index], comparison.timezone, locale);
+    });
+    return [current, ...priors]
+        .filter((part) => !!part)
+        .join(WINDOWS_SEPARATOR);
+}
+// One prior lane: 'vs previous month: Aug 1 – 15, 2026', or its label alone
+// when the server sends no window for it.
+function priorWindowText(offset, prior, timezone, locale) {
+    const label = comparisonOffsetLabel(offset);
+    const days = prior ? formatDayWindow(prior, timezone, locale) : '';
+    return days ? `${label}: ${days}` : label;
+}
+function comparisonNotes(comparison) {
+    return (comparison?.notes ?? []).map((code) => comparisonNoteText(code, comparison));
+}
+// Why a KPI card's delta reads as it does ('No baseline: the previous period
+// has no data.'), naming the baseline by what the first lane compares against.
+function kpiNote(kpi, comparison) {
+    return kpi?.note ? kpiNoteText(kpi.note, comparison?.offsets?.[0]?.against) : '';
+}
+// One line per windowed value, named by its column when there are several.
+function windowDescriptions(data, locale) {
+    const windows = Object.entries(data.windows ?? {});
+    return windows.map(([alias, meta]) => {
+        const text = windowText(meta, locale, data.granularity);
+        return windows.length > 1 ? `${alias}: ${text}` : text;
+    });
+}
+function windowNotes(data, locale) {
+    return Object.values(data.windows ?? {})
+        .flatMap((meta) => (meta.notes ?? []).map((code) => windowNoteText(code, meta, locale, data.granularity)));
+}
+// A compared column's windows. In range mode every row compares the same two
+// windows, so they are named, and read on one day the days the values are
+// read on are; over a series or a spine of periods each row compares its own
+// period, so only the lane is.
+function comparisonSentence(output, comparison, locale) {
+    if (!output.role || !comparison) {
+        return '';
+    }
+    const offset = comparison.offsets?.[(output.offset ?? 1) - 1] ?? null;
+    const current = comparison.current ? formatDayWindow(comparison.current, comparison.timezone, locale) : '';
+    const priorWindow = comparison.priors?.[(output.offset ?? 1) - 1];
+    const prior = priorWindow ? formatDayWindow(priorWindow, comparison.timezone, locale) : '';
+    if (comparison.mode === 'range' && current && (output.role === 'current' || prior)) {
+        return rangeSentence(output.role, current, prior, offset);
+    }
+    if (isReadOnOneDay(comparison) && comparison.current && priorWindow) {
+        return readingDaySentence(output.role, comparison.current, priorWindow, offset, locale);
+    }
+    return output.role === 'current' || !offset ? '' : `${ROLE_LEADS[output.role]} ${comparisonOffsetLabel(offset)}.`;
+}
+function rangeSentence(role, current, prior, offset) {
+    switch (role) {
+        case 'current':
+            return `Value for ${current}.`;
+        case 'prior':
+            return offset ? `Prior value for ${prior} (${comparisonOffsetLabel(offset)}).` : `Prior value for ${prior}.`;
+        default:
+            return `${ROLE_LEADS[role]} from ${prior} to ${current}.`;
+    }
+}
+// A column of a comparison read on one day, named by the days its values are
+// read on: 'Prior value on Aug 31, 2026 (vs previous month).'
+function readingDaySentence(role, currentWindow, priorWindow, offset, locale) {
+    const current = formatReadingDay(currentWindow, locale);
+    const prior = formatReadingDay(priorWindow, locale);
+    switch (role) {
+        case 'current':
+            return `Value ${current}.`;
+        case 'prior':
+            return offset ? `Prior value ${prior} (${comparisonOffsetLabel(offset)}).` : `Prior value ${prior}.`;
+        default:
+            return `${ROLE_LEADS[role]} from the value ${prior} to the value ${current}.`;
+    }
+}
+// 'Rank by Revenue, 1 being the largest, within each Region. Tied values share
+// a rank (1, 1, 3).' A measure written as its own rank ranks by the value it
+// would otherwise show, so it names no other measure ('Rank, 1 being the
+// largest, across all rows.').
+function rankSentence(output, outputs) {
+    const rank = output.kind === 'rank' ? output.rank : null;
+    if (!rank) {
+        return '';
+    }
+    const end = rank.direction === 'asc' ? 'smallest' : 'largest';
+    const scope = rank.within?.length ? `within each ${joinNames(rank.within)}` : 'across all rows';
+    const ties = rank.method === 'dense' ? '1, 1, 2' : '1, 1, 3';
+    const by = isOwnOutput(output, outputs) ? '' : ` by ${output.measure}`;
+    return `Rank${by}, 1 being the ${end}, ${scope}. Tied values share a rank (${ties}). `
+        + FILTERED_ROWS_SENTENCE;
+}
+// 'Share of the total Revenue within each Region.' A measure written as its
+// own share names no other measure ('Share of the total within each
+// Region.', 'Share of the total across all rows.').
+function shareSentence(output, outputs) {
+    const share = output.kind === 'share' ? output.share : null;
+    if (!share) {
+        return '';
+    }
+    if (isOwnOutput(output, outputs)) {
+        const scope = share.within?.length ? `within each ${joinNames(share.within)}` : 'across all rows';
+        return `Share of the total ${scope}. ${FILTERED_ROWS_SENTENCE}`;
+    }
+    const scope = share.within?.length ? ` within each ${joinNames(share.within)}` : '';
+    return `Share of the total ${output.measure}${scope}. ${FILTERED_ROWS_SENTENCE}`;
+}
+// Whether a rank or a share is its measure's own output: the server writes a
+// measure with a rank or a share as that rank or share, so its measure is a
+// column of the same kind (itself, or for a prior or a change the current
+// column), never a value of its own to name.
+function isOwnOutput(output, outputs) {
+    return outputs?.[output.measure]?.kind === output.kind;
+}
+// A windowed column: what it is, then why it reads as it does.
+function windowSentences(meta, locale, data) {
+    if (!meta) {
+        return '';
+    }
+    const notes = (meta.notes ?? []).map((code) => windowNoteText(code, meta, locale, data.granularity));
+    return [`${windowText(meta, locale, data.granularity)}.`, ...notes].join(' ');
+}
+// 'Region', 'Region and Channel', 'Region, Channel and Plan'.
+function joinNames(names) {
+    return names.length > 1
+        ? `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]}`
+        : names.join('');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"output-notes.js","sourceRoot":"","sources":["../../../../src/app/reports/output-notes.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  comparisonNoteText,\n  comparisonOffsetLabel,\n  formatDayRange,\n  formatDayWindow,\n  formatReadingDay,\n  isReadOnOneDay,\n  kpiNoteText,\n  windowNoteText,\n  windowText,\n} from './format';\nimport {\n  ComparisonOffset,\n  ComparisonWindow,\n  ComponentComparison,\n  ComponentData,\n  ComponentKpi,\n  OutputMeta,\n  OutputRole,\n  ReportLocaleTag,\n  WindowMeta,\n} from './interfaces/report.interface';\n\n\n// The notes a component shows about the numbers it draws: which days a\n// comparison compares, why it reads as it does, and how its windowed values\n// were computed. The server sends windows, fields and codes; every sentence is\n// worded here, through format.ts, in English with the days in the report's\n// locale. A component whose data carries none of those keys has no note.\n\n// The ComponentData keys a note reads.\nexport type ComponentNoteData = Pick<\n  ComponentData,\n  'comparison' | 'timeframe' | 'outputs' | 'cellMeasures' | 'windows' | 'granularity' | 'kpi'\n>;\n\n// The report the note is written for: its locale, and the zone a timeframe's\n// cut time reads in (a comparison names its own).\nexport interface ComponentNoteContext {\n  locale: ReportLocaleTag;\n  timezone: string;\n}\n\n// Which parts of the note a component shows. Omitted, a part is shown, except\n// the window descriptions, which a chart's tooltips and a list's headers carry\n// instead.\nexport interface ComponentNoteParts {\n  // The days the component reads: its comparison's current and prior windows,\n  // else its timeframe's days.\n  windows?: boolean;\n  // What each windowed value is ('Rolling 3-month total, Sep 1 – 30, 2026').\n  windowDescriptions?: boolean;\n  // Why the windowed values read as they do.\n  windowNotes?: boolean;\n}\n\n// Between the current window and each prior one on the windows line.\nconst WINDOWS_SEPARATOR = ' · ';\n\n// Ranks and shares are computed after the viewer's filters, never before.\nconst FILTERED_ROWS_SENTENCE = 'Computed over the rows the filters keep.';\n\nconst ROLE_LEADS: Record<OutputRole, string> = {\n  current: 'Value',\n  prior: 'Prior value',\n  change: 'Change',\n  percent_change: 'Percent change',\n};\n\n// The note's lines, in order: the windows, then the comparison's notes and a\n// KPI's delta note, then the windowed values' descriptions and notes. A line is never repeated (two\n// windowed values often share a note). Empty when the data has none of the\n// keys, or none of the parts asked for.\nexport function componentNoteLines(\n  data: ComponentNoteData | null | undefined,\n  context: ComponentNoteContext,\n  parts: ComponentNoteParts = {},\n): string[] {\n  if (!data) {\n    return [];\n  }\n\n  const lines = [\n    parts.windows === false ? '' : componentWindowsLine(data, context),\n    ...comparisonNotes(data.comparison),\n    kpiNote(data.kpi, data.comparison),\n    ...(parts.windowDescriptions ? windowDescriptions(data, context.locale) : []),\n    ...(parts.windowNotes === false ? [] : windowNotes(data, context.locale)),\n  ];\n\n  return [...new Set(lines.filter((line) => !!line))];\n}\n\n// What one output column holds, for its header's tooltip: the windows a\n// compared value covers, a rank's or a share's scope, and how a windowed value\n// was computed. A cross-tab cell column reads its measure's meaning through\n// cellMeasures. '' for a plain column.\nexport function outputColumnNote(\n  column: string,\n  data: ComponentNoteData | null | undefined,\n  locale: ReportLocaleTag,\n): string {\n  const alias = data?.cellMeasures?.[column] ?? column;\n  const output = data?.outputs?.[alias];\n\n  if (!output) {\n    return '';\n  }\n\n  return [\n    comparisonSentence(output, data.comparison, locale),\n    rankSentence(output, data.outputs),\n    shareSentence(output, data.outputs),\n    windowSentences(data.windows?.[alias], locale, data),\n  ]\n    .filter((sentence) => !!sentence)\n    .join(' ');\n}\n\n// 'Sep 1 – 15, 2026 · vs previous month: Aug 1 – 15, 2026'. A comparison\n// with no current window yet has no line (its no_window note says so); a\n// component without a comparison shows its timeframe's days. '' when the data\n// has neither. The note's first line, and the PDF and PowerPoint exports'\n// subtitle under a chart's or a list's title.\nexport function componentWindowsLine(data: ComponentNoteData, context: ComponentNoteContext): string {\n  const comparison = data.comparison;\n\n  if (comparison) {\n    return comparison.current ? comparisonWindowsLine(comparison, comparison.current, context.locale) : '';\n  }\n\n  return data.timeframe ? formatDayWindow(data.timeframe, context.timezone, context.locale) : '';\n}\n\n// Read on one day, the line names the days the values are read on: 'On Sep\n// 15, 2026 · vs previous month: Aug 31, 2026'.\nfunction comparisonWindowsLine(\n  comparison: ComponentComparison,\n  currentWindow: ComparisonWindow,\n  locale: ReportLocaleTag,\n): string {\n  if (isReadOnOneDay(comparison)) {\n    const priors = (comparison.offsets ?? []).map((offset, index) => {\n      const prior = comparison.priors?.[index];\n      const day = prior ? formatDayRange(prior.end, prior.end, locale) : '';\n\n      return day ? `${comparisonOffsetLabel(offset)}: ${day}` : comparisonOffsetLabel(offset);\n    });\n\n    return [formatReadingDay(currentWindow, locale, true), ...priors]\n      .filter((part) => !!part)\n      .join(WINDOWS_SEPARATOR);\n  }\n\n  const current = formatDayWindow(currentWindow, comparison.timezone, locale);\n  const priors = (comparison.offsets ?? []).map((offset, index) => {\n    return priorWindowText(offset, comparison.priors?.[index], comparison.timezone, locale);\n  });\n\n  return [current, ...priors]\n    .filter((part) => !!part)\n    .join(WINDOWS_SEPARATOR);\n}\n\n// One prior lane: 'vs previous month: Aug 1 – 15, 2026', or its label alone\n// when the server sends no window for it.\nfunction priorWindowText(\n  offset: ComparisonOffset,\n  prior: ComparisonWindow | undefined,\n  timezone: string,\n  locale: ReportLocaleTag,\n): string {\n  const label = comparisonOffsetLabel(offset);\n  const days = prior ? formatDayWindow(prior, timezone, locale) : '';\n\n  return days ? `${label}: ${days}` : label;\n}\n\nfunction comparisonNotes(comparison: ComponentComparison | null | undefined): string[] {\n  return (comparison?.notes ?? []).map((code) => comparisonNoteText(code, comparison));\n}\n\n// Why a KPI card's delta reads as it does ('No baseline: the previous period\n// has no data.'), naming the baseline by what the first lane compares against.\nfunction kpiNote(\n  kpi: ComponentKpi | null | undefined,\n  comparison: ComponentComparison | null | undefined,\n): string {\n  return kpi?.note ? kpiNoteText(kpi.note, comparison?.offsets?.[0]?.against) : '';\n}\n\n// One line per windowed value, named by its column when there are several.\nfunction windowDescriptions(data: ComponentNoteData, locale: ReportLocaleTag): string[] {\n  const windows = Object.entries(data.windows ?? {});\n\n  return windows.map(([alias, meta]) => {\n    const text = windowText(meta, locale, data.granularity);\n\n    return windows.length > 1 ? `${alias}: ${text}` : text;\n  });\n}\n\nfunction windowNotes(data: ComponentNoteData, locale: ReportLocaleTag): string[] {\n  return Object.values(data.windows ?? {})\n    .flatMap((meta) => (meta.notes ?? []).map((code) => windowNoteText(code, meta, locale, data.granularity)));\n}\n\n// A compared column's windows. In range mode every row compares the same two\n// windows, so they are named, and read on one day the days the values are\n// read on are; over a series or a spine of periods each row compares its own\n// period, so only the lane is.\nfunction comparisonSentence(\n  output: OutputMeta,\n  comparison: ComponentComparison | null | undefined,\n  locale: ReportLocaleTag,\n): string {\n  if (!output.role || !comparison) {\n    return '';\n  }\n\n  const offset = comparison.offsets?.[(output.offset ?? 1) - 1] ?? null;\n  const current = comparison.current ? formatDayWindow(comparison.current, comparison.timezone, locale) : '';\n  const priorWindow = comparison.priors?.[(output.offset ?? 1) - 1];\n  const prior = priorWindow ? formatDayWindow(priorWindow, comparison.timezone, locale) : '';\n\n  if (comparison.mode === 'range' && current && (output.role === 'current' || prior)) {\n    return rangeSentence(output.role, current, prior, offset);\n  }\n\n  if (isReadOnOneDay(comparison) && comparison.current && priorWindow) {\n    return readingDaySentence(output.role, comparison.current, priorWindow, offset, locale);\n  }\n\n  return output.role === 'current' || !offset ? '' : `${ROLE_LEADS[output.role]} ${comparisonOffsetLabel(offset)}.`;\n}\n\nfunction rangeSentence(role: OutputRole, current: string, prior: string, offset: ComparisonOffset | null): string {\n  switch (role) {\n    case 'current':\n      return `Value for ${current}.`;\n    case 'prior':\n      return offset ? `Prior value for ${prior} (${comparisonOffsetLabel(offset)}).` : `Prior value for ${prior}.`;\n    default:\n      return `${ROLE_LEADS[role]} from ${prior} to ${current}.`;\n  }\n}\n\n// A column of a comparison read on one day, named by the days its values are\n// read on: 'Prior value on Aug 31, 2026 (vs previous month).'\nfunction readingDaySentence(\n  role: OutputRole,\n  currentWindow: ComparisonWindow,\n  priorWindow: ComparisonWindow,\n  offset: ComparisonOffset | null,\n  locale: ReportLocaleTag,\n): string {\n  const current = formatReadingDay(currentWindow, locale);\n  const prior = formatReadingDay(priorWindow, locale);\n\n  switch (role) {\n    case 'current':\n      return `Value ${current}.`;\n    case 'prior':\n      return offset ? `Prior value ${prior} (${comparisonOffsetLabel(offset)}).` : `Prior value ${prior}.`;\n    default:\n      return `${ROLE_LEADS[role]} from the value ${prior} to the value ${current}.`;\n  }\n}\n\n// 'Rank by Revenue, 1 being the largest, within each Region. Tied values share\n// a rank (1, 1, 3).' A measure written as its own rank ranks by the value it\n// would otherwise show, so it names no other measure ('Rank, 1 being the\n// largest, across all rows.').\nfunction rankSentence(output: OutputMeta, outputs: Record<string, OutputMeta> | null | undefined): string {\n  const rank = output.kind === 'rank' ? output.rank : null;\n\n  if (!rank) {\n    return '';\n  }\n\n  const end = rank.direction === 'asc' ? 'smallest' : 'largest';\n  const scope = rank.within?.length ? `within each ${joinNames(rank.within)}` : 'across all rows';\n  const ties = rank.method === 'dense' ? '1, 1, 2' : '1, 1, 3';\n  const by = isOwnOutput(output, outputs) ? '' : ` by ${output.measure}`;\n\n  return `Rank${by}, 1 being the ${end}, ${scope}. Tied values share a rank (${ties}). `\n    + FILTERED_ROWS_SENTENCE;\n}\n\n// 'Share of the total Revenue within each Region.' A measure written as its\n// own share names no other measure ('Share of the total within each\n// Region.', 'Share of the total across all rows.').\nfunction shareSentence(output: OutputMeta, outputs: Record<string, OutputMeta> | null | undefined): string {\n  const share = output.kind === 'share' ? output.share : null;\n\n  if (!share) {\n    return '';\n  }\n\n  if (isOwnOutput(output, outputs)) {\n    const scope = share.within?.length ? `within each ${joinNames(share.within)}` : 'across all rows';\n\n    return `Share of the total ${scope}. ${FILTERED_ROWS_SENTENCE}`;\n  }\n\n  const scope = share.within?.length ? ` within each ${joinNames(share.within)}` : '';\n\n  return `Share of the total ${output.measure}${scope}. ${FILTERED_ROWS_SENTENCE}`;\n}\n\n// Whether a rank or a share is its measure's own output: the server writes a\n// measure with a rank or a share as that rank or share, so its measure is a\n// column of the same kind (itself, or for a prior or a change the current\n// column), never a value of its own to name.\nfunction isOwnOutput(output: OutputMeta, outputs: Record<string, OutputMeta> | null | undefined): boolean {\n  return outputs?.[output.measure]?.kind === output.kind;\n}\n\n// A windowed column: what it is, then why it reads as it does.\nfunction windowSentences(\n  meta: WindowMeta | undefined,\n  locale: ReportLocaleTag,\n  data: ComponentNoteData,\n): string {\n  if (!meta) {\n    return '';\n  }\n\n  const notes = (meta.notes ?? []).map((code) => windowNoteText(code, meta, locale, data.granularity));\n\n  return [`${windowText(meta, locale, data.granularity)}.`, ...notes].join(' ');\n}\n\n// 'Region', 'Region and Channel', 'Region, Channel and Plan'.\nfunction joinNames(names: string[]): string {\n  return names.length > 1\n    ? `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]}`\n    : names.join('');\n}\n"]}

package/esm2022/app/reports/pipes/report-output.pipe.mjs

@@ -0,0 +1,28 @@
+import { Pipe } from '@angular/core';
+import { formatOutputValue } from '../format';
+import * as i0 from "@angular/core";
+// A list cell (or a totals cell) of an output column, written by what it holds:
+// a prior or a change in its measure's format, a signed percent change, a
+// change of a rate in points, a rank as a whole number, a share as a percent.
+// It reads the whole row, since a change looks up its prior beside it to tell
+// a missing baseline ('—') from a zero one ('n/a'). An empty value reads ''.
+export class ReportOutputPipe {
+    transform(row, column, output, context) {
+        return formatOutputValue(row?.[column.column], output.output, column, context, {
+            measureSpec: output.measureSpec,
+            prior: output.priorAlias && row ? row[output.priorAlias] : undefined,
+            floor: output.floor,
+            empty: '',
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportOutputPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: ReportOutputPipe, isStandalone: true, name: "fsReportOutput" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportOutputPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'fsReportOutput',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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