@firestitch/report 18.8.1 → 18.10.0

package/esm2022/app/reports/tile-data-state.mjs

@@ -0,0 +1,127 @@
+import { isMatchAnyGroup } from './report-filter-items';
+import { isTile } from './report-tile';
+import { isChartGranularity } from './report-view-config';
+// Whether a component is a chart on a time x-axis: the only component the
+// report's group-by grain applies to. A deliberate mirror of the server's
+// ReportQueryRunner::_isTimeSeriesChart, which is canonical and drops the
+// grain for every other component; kept so a product pinned to an older
+// framework does not re-bucket a non-time chart.
+export function isTimeSeriesChart(component) {
+    return component.type === 'chart' && component.config?.xAxis?.kind === 'time';
+}
+// The interaction state one tile's data request carries, read off a view
+// document of the screen (the state service's snapshot()): the group-by grain
+// for a time-series chart, a list's sort, search and hidden columns, a
+// chart's drill path, and, while the groups match 'any', the groups that
+// combine (matchAnyGroupIds). The tile on screen, its CSV, the PDF and
+// PowerPoint collector and the zip all build their state here, so a file
+// always holds what the screen shows. A list's paging is the caller's. Never
+// sets unchangedIfUnreached: that belongs to an on-screen refetch alone.
+//
+// A drill path and the grain may both be sent: the server lets the drilled
+// level win, and a server that does not drill keeps the grain.
+export function tileDataState(report, component, snapshot) {
+    const state = {};
+    if (!isTile(component)) {
+        return state;
+    }
+    const tile = snapshot.tiles?.[component.id];
+    if (isTimeSeriesChart(component) && isChartGranularity(snapshot.groupBy)) {
+        state.frequency = snapshot.groupBy;
+    }
+    if (component.type === 'list') {
+        if (tile?.sort?.column) {
+            state.sort = { ...tile.sort };
+        }
+        if (tile?.search) {
+            state.search = tile.search;
+        }
+        if (tile?.hidden?.length) {
+            state.hiddenColumns = [...tile.hidden];
+        }
+    }
+    if (component.type === 'chart' && tile?.drill?.length) {
+        state.drill = tile.drill.map((step) => ({ ...step }));
+    }
+    const matchAnyGroupIds = tileMatchAnyGroupIds(report, component, snapshot);
+    if (matchAnyGroupIds.length) {
+        state.matchAnyGroupIds = matchAnyGroupIds;
+    }
+    return state;
+}
+// Each tile's state for the zip export (tileDataState), by component id: the
+// tiles of every page, or of `pageId` alone. The zip holds no header or
+// footer tile. A tile with nothing to send is left out, so an untouched report
+// sends no states at all.
+export function zipExportStates(report, snapshot, pageId = null) {
+    const states = {};
+    (report.pages ?? [])
+        .filter((page) => !pageId || page.id === pageId)
+        .flatMap((page) => page.components ?? [])
+        .forEach((component) => {
+        const state = tileDataState(report, component, snapshot);
+        if (Object.keys(state).length) {
+            states[component.id] = state;
+        }
+    });
+    return states;
+}
+// The groups a tile's 'any' combines, in id order: while the snapshot's
+// match is 'any', every eligible group that holds a value. A group the tile
+// has no member of is listed too, so the server can tell a tile that cannot
+// test every group (it then applies none of them and says so). A page group
+// counts only for the tiles of its own page: it is in the report bar of no
+// other page. A header or footer tile is a tile of the page on screen.
+function tileMatchAnyGroupIds(report, component, snapshot) {
+    if (!report) {
+        return [];
+    }
+    return matchAnyGroupIdsOnPage(report, tilePageId(report, component, snapshot), snapshot);
+}
+// The groups a layer's inline values combine (the page values request's
+// matchAnyGroupIds), by the tile rule (tileDataState): while the snapshot's
+// match is 'any', every eligible group that holds a value, in id order. A
+// value has no member of some of them, and the server then applies none of
+// them to it, as it does for such a tile. `layerId` is the page the values
+// sit on; the header and footer's values (any other id) are values of the
+// page on screen, as a header or footer tile is.
+export function valuesMatchAnyGroupIds(report, layerId, snapshot) {
+    if (!report) {
+        return [];
+    }
+    const page = (report.pages ?? []).find((candidate) => candidate.id === layerId);
+    return matchAnyGroupIdsOnPage(report, page?.id ?? snapshot.pageId ?? null, snapshot);
+}
+// While the snapshot's match is 'any': the eligible groups of the report bar
+// on `pageId` that hold a value, in id order.
+function matchAnyGroupIdsOnPage(report, pageId, snapshot) {
+    if (snapshot.match !== 'any') {
+        return [];
+    }
+    return (report.filterGroups ?? [])
+        .filter((group) => isMatchAnyGroup(group, pageId) && holdsValue(snapshot.groups?.[group.id]))
+        .map((group) => group.id)
+        .sort((a, b) => a - b);
+}
+// The page a tile is drawn on: its own page, or, for a header or footer
+// tile, the page on screen. Null when neither is known. An inline value's
+// page is the page whose values hold it, the same way.
+export function tilePageId(report, component, snapshot) {
+    const page = (report.pages ?? [])
+        .find((candidate) => [...(candidate.components ?? []), ...(candidate.values ?? [])]
+        .some((item) => item.id === component.id));
+    return page?.id ?? snapshot.pageId ?? null;
+}
+// Whether a group's stored value holds something a request sends: picks to
+// keep or leave out, text, or a number range end (0 is an end).
+function holdsValue(value) {
+    if (!value) {
+        return false;
+    }
+    return !!value.values?.length
+        || !!value.excludeValues?.length
+        || (typeof value.value === 'string' && !!value.value.trim())
+        || Number.isFinite(value.min)
+        || Number.isFinite(value.max);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tile-data-state.js","sourceRoot":"","sources":["../../../../src/app/reports/tile-data-state.ts"],"names":[],"mappings":"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","sourcesContent":["import { ReportViewConfig } from './interfaces/report-view-config.interface';\nimport {\n  ComponentDataState,\n  FilterGroupDefault,\n  Report,\n  ReportComponent,\n} from './interfaces/report.interface';\nimport { isMatchAnyGroup } from './report-filter-items';\nimport { isTile } from './report-tile';\nimport { isChartGranularity } from './report-view-config';\n\n\n// Whether a component is a chart on a time x-axis: the only component the\n// report's group-by grain applies to. A deliberate mirror of the server's\n// ReportQueryRunner::_isTimeSeriesChart, which is canonical and drops the\n// grain for every other component; kept so a product pinned to an older\n// framework does not re-bucket a non-time chart.\nexport function isTimeSeriesChart(component: ReportComponent): boolean {\n  return component.type === 'chart' && component.config?.xAxis?.kind === 'time';\n}\n\n\n// The interaction state one tile's data request carries, read off a view\n// document of the screen (the state service's snapshot()): the group-by grain\n// for a time-series chart, a list's sort, search and hidden columns, a\n// chart's drill path, and, while the groups match 'any', the groups that\n// combine (matchAnyGroupIds). The tile on screen, its CSV, the PDF and\n// PowerPoint collector and the zip all build their state here, so a file\n// always holds what the screen shows. A list's paging is the caller's. Never\n// sets unchangedIfUnreached: that belongs to an on-screen refetch alone.\n//\n// A drill path and the grain may both be sent: the server lets the drilled\n// level win, and a server that does not drill keeps the grain.\nexport function tileDataState(\n  report: Report | null,\n  component: ReportComponent,\n  snapshot: ReportViewConfig,\n): ComponentDataState {\n  const state: ComponentDataState = {};\n\n  if (!isTile(component)) {\n    return state;\n  }\n\n  const tile = snapshot.tiles?.[component.id];\n\n  if (isTimeSeriesChart(component) && isChartGranularity(snapshot.groupBy)) {\n    state.frequency = snapshot.groupBy;\n  }\n\n  if (component.type === 'list') {\n    if (tile?.sort?.column) {\n      state.sort = { ...tile.sort };\n    }\n    if (tile?.search) {\n      state.search = tile.search;\n    }\n    if (tile?.hidden?.length) {\n      state.hiddenColumns = [...tile.hidden];\n    }\n  }\n\n  if (component.type === 'chart' && tile?.drill?.length) {\n    state.drill = tile.drill.map((step) => ({ ...step }));\n  }\n\n  const matchAnyGroupIds = tileMatchAnyGroupIds(report, component, snapshot);\n  if (matchAnyGroupIds.length) {\n    state.matchAnyGroupIds = matchAnyGroupIds;\n  }\n\n  return state;\n}\n\n\n// Each tile's state for the zip export (tileDataState), by component id: the\n// tiles of every page, or of `pageId` alone. The zip holds no header or\n// footer tile. A tile with nothing to send is left out, so an untouched report\n// sends no states at all.\nexport function zipExportStates(\n  report: Report,\n  snapshot: ReportViewConfig,\n  pageId: number | null = null,\n): Record<number, ComponentDataState> {\n  const states: Record<number, ComponentDataState> = {};\n\n  (report.pages ?? [])\n    .filter((page) => !pageId || page.id === pageId)\n    .flatMap((page) => page.components ?? [])\n    .forEach((component) => {\n      const state = tileDataState(report, component, snapshot);\n\n      if (Object.keys(state).length) {\n        states[component.id] = state;\n      }\n    });\n\n  return states;\n}\n\n\n// The groups a tile's 'any' combines, in id order: while the snapshot's\n// match is 'any', every eligible group that holds a value. A group the tile\n// has no member of is listed too, so the server can tell a tile that cannot\n// test every group (it then applies none of them and says so). A page group\n// counts only for the tiles of its own page: it is in the report bar of no\n// other page. A header or footer tile is a tile of the page on screen.\nfunction tileMatchAnyGroupIds(report: Report | null, component: ReportComponent, snapshot: ReportViewConfig): number[] {\n  if (!report) {\n    return [];\n  }\n\n  return matchAnyGroupIdsOnPage(report, tilePageId(report, component, snapshot), snapshot);\n}\n\n\n// The groups a layer's inline values combine (the page values request's\n// matchAnyGroupIds), by the tile rule (tileDataState): while the snapshot's\n// match is 'any', every eligible group that holds a value, in id order. A\n// value has no member of some of them, and the server then applies none of\n// them to it, as it does for such a tile. `layerId` is the page the values\n// sit on; the header and footer's values (any other id) are values of the\n// page on screen, as a header or footer tile is.\nexport function valuesMatchAnyGroupIds(\n  report: Report | null,\n  layerId: number | null,\n  snapshot: ReportViewConfig,\n): number[] {\n  if (!report) {\n    return [];\n  }\n\n  const page = (report.pages ?? []).find((candidate) => candidate.id === layerId);\n\n  return matchAnyGroupIdsOnPage(report, page?.id ?? snapshot.pageId ?? null, snapshot);\n}\n\n\n// While the snapshot's match is 'any': the eligible groups of the report bar\n// on `pageId` that hold a value, in id order.\nfunction matchAnyGroupIdsOnPage(report: Report, pageId: number | null, snapshot: ReportViewConfig): number[] {\n  if (snapshot.match !== 'any') {\n    return [];\n  }\n\n  return (report.filterGroups ?? [])\n    .filter((group) => isMatchAnyGroup(group, pageId) && holdsValue(snapshot.groups?.[group.id]))\n    .map((group) => group.id)\n    .sort((a, b) => a - b);\n}\n\n\n// The page a tile is drawn on: its own page, or, for a header or footer\n// tile, the page on screen. Null when neither is known. An inline value's\n// page is the page whose values hold it, the same way.\nexport function tilePageId(report: Report, component: ReportComponent, snapshot: ReportViewConfig): number | null {\n  const page = (report.pages ?? [])\n    .find((candidate) => [...(candidate.components ?? []), ...(candidate.values ?? [])]\n      .some((item) => item.id === component.id));\n\n  return page?.id ?? snapshot.pageId ?? null;\n}\n\n\n// Whether a group's stored value holds something a request sends: picks to\n// keep or leave out, text, or a number range end (0 is an end).\nfunction holdsValue(value: FilterGroupDefault | null | undefined): boolean {\n  if (!value) {\n    return false;\n  }\n\n  return !!value.values?.length\n    || !!value.excludeValues?.length\n    || (typeof value.value === 'string' && !!value.value.trim())\n    || Number.isFinite(value.min)\n    || Number.isFinite(value.max);\n}\n"]}

package/esm2022/app/reports/tile-loads.mjs

@@ -0,0 +1,38 @@
+import { catchError, filter, map, merge, of, switchMap, timer } from 'rxjs';
+// A sweep of changes (a few filters set in a row, every value of an applied
+// view) settles for this long before a tile refetches, so the sweep costs one
+// request, not one per change.
+export const TILE_REFRESH_DEBOUNCE_MS = 300;
+// A tile's data as one stream: the first load at once, then one load per
+// settled burst of refresh triggers.
+//
+// - Each trigger starts over (switchMap): it cancels the wait for the one
+//   before it and the request in flight, then waits for the sweep to settle.
+//   So an answer to an older request never lands, not even while the next
+//   load still waits, and the bar stays on until the settled load answers.
+// - Each load notes the state version it was sent under (stateVersion), and
+//   its answer is dropped when the version has moved since. apply() and
+//   resetToBase() move the version and announce a full change together, so
+//   the load for the new state is already on its way.
+// - A failed load ends only itself: its message comes through as the answer,
+//   and the next trigger loads again.
+export function tileLoads(refresh$, load, version) {
+    return merge(of(0), refresh$.pipe(map(() => TILE_REFRESH_DEBOUNCE_MS)))
+        .pipe(switchMap((wait) => (wait ? timer(wait) : of(0))
+        .pipe(switchMap(() => oneLoad(load, version)))));
+}
+// One request: its answer, or its failure as a message, dropped when the
+// state version moved while it was out.
+function oneLoad(load, version) {
+    const sentAt = version();
+    return load()
+        .pipe(map((data) => ({ data, error: null })), catchError((error) => of({ data: null, error: loadErrorMessage(error) })), filter(() => version() === sentAt));
+}
+// What a failed request says: the server's message, else the error's own,
+// else a plain fallback.
+function loadErrorMessage(error) {
+    const failure = error;
+    const message = failure?.error?.message ?? failure?.message;
+    return typeof message === 'string' && message ? message : 'Failed to load data';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/reports/values.mjs

@@ -0,0 +1,183 @@
+import { ReportValueFormula } from './enums/report-value-formula.enum';
+import { formatOutputValue } from './format';
+import { VALUE_EMPTY_TEXT, VALUE_TOKEN_PATTERN } from './text';
+// Live values inside text blocks: which values a page's text shows, and what
+// each token reads as. A value belongs to a page (the master for a header or
+// footer) and is listed in its `values`, never in its components. Pure, so the
+// canvas and both exports fill a block's tokens the same way.
+// No value keys: what a text block is told other blocks show when nothing
+// says otherwise. Shared, and typed read-only so no caller fills it.
+export const NO_VALUE_KEYS = Object.freeze(new Set());
+// The keys an html's {{value.<key>}} tokens name: lowercased, each once, in
+// the order they first appear.
+export function valueKeys(html) {
+    const keys = Array.from((html ?? '').matchAll(VALUE_TOKEN_PATTERN), (match) => match[1].toLowerCase());
+    return [...new Set(keys)];
+}
+// The key a value's tokens name, as they are compared: lowercase.
+export function valueKey(component) {
+    return String(component.config?.key ?? '').toLowerCase();
+}
+// The keys a formula value reads (config.formula.of), as they are compared:
+// lowercase. None for a query value.
+export function operandKeys(value) {
+    const of = value.config?.formula?.of;
+    return Array.isArray(of) ? of.map((key) => String(key).toLowerCase()) : [];
+}
+// The values some text shows, in id order: what the server reads for the
+// page. A key held by two values (a race between two writes) is the newest
+// one's, as server-side.
+export function shownValues(values, texts) {
+    const shown = new Set(texts.flatMap((text) => valueKeys(text.config?.html)));
+    const ordered = byId(values);
+    const newest = new Map(ordered.map((value) => [valueKey(value), value]));
+    return ordered.filter((value) => shown.has(valueKey(value)) && newest.get(valueKey(value)) === value);
+}
+// The keys a layer reads when its text shows `shown`: those keys, and the
+// operands of each shown formula, one level deep. It mirrors the server's
+// ReportTextValues::getReadKeys, and is used only for the editor's notice: the
+// server's own read set decides which numbers come back.
+export function readKeys(shown, values) {
+    const keys = new Set(shown);
+    // Over a copy of the shown keys, so an operand added here is not expanded.
+    [...keys].forEach((key) => {
+        (values[key]?.reads ?? []).forEach((read) => keys.add(read));
+    });
+    return keys;
+}
+// What each of a layer's values reads as, by key, for its text's tokens and
+// chips. Every value is listed, shown or not, so a pasted chip keeps its name.
+// A value reads as loading until the layer's numbers have arrived (`results`
+// is null until then) and while a request still on its way asks for it
+// (`loading`, by id): a number on screen is always the current request's. A
+// value with no row, or whose row failed, has no text (the em dash).
+export function textValues(values, results, format, loading = new Set()) {
+    const filled = {};
+    byId(values).forEach((value) => {
+        const key = valueKey(value);
+        const name = value.title || key;
+        const row = results?.rows.get(value.id);
+        const reads = formulaReads(value);
+        if (!results || loading.has(value.id)) {
+            filled[key] = { name, loading: true, ...reads };
+        }
+        else if (row && !row.error) {
+            filled[key] = { name, text: formatValueText(value, row, values, format), ...reads };
+        }
+        else {
+            filled[key] = { name, ...reads };
+        }
+    });
+    return filled;
+}
+// A value's number as its token reads it, on the canvas and in both exports,
+// through the formatOutputValue KPI cards and list cells use. A query value
+// that shows a comparison output, and a formula, are written by their role: a
+// change or a percent change is signed (unless the formula's `signed` says
+// otherwise), and a change in points carries no ' pp', as the words around
+// the token carry the unit. A change or a sum with no format of its own takes
+// its first operand's, and a ratio reads a percent format as a 0-1 fraction.
+// A row with an error reads as the em dash.
+export function formatValueText(value, row, layerValues, ctx) {
+    if (row.error) {
+        return VALUE_EMPTY_TEXT;
+    }
+    const formula = value.config?.formula ?? null;
+    const output = row.role || formula
+        ? {
+            measure: valueKey(value),
+            kind: 'value',
+            role: row.role ?? null,
+            offset: null,
+            window: false,
+            rank: null,
+            share: null,
+        }
+        : null;
+    const context = formula?.op === ReportValueFormula.Ratio ? { ...ctx, ratioPercent: true } : ctx;
+    return formatOutputValue(row.value, output, value.config?.measure, context, {
+        empty: VALUE_EMPTY_TEXT,
+        measureSpec: operandSpec(formula, layerValues),
+        signed: formula?.signed ?? undefined,
+        pointsUnit: false,
+    }).text;
+}
+// The keys of the values that came back without a number to show: no row for
+// them, or a row with an error. What an export's gate names as failed.
+export function failedValueKeys(values, rows) {
+    const failed = values
+        .filter((value) => {
+        const row = rows.get(value.id);
+        return !row || !!row.error;
+    })
+        .map(valueKey);
+    return [...new Set(failed)];
+}
+// Whether two token value sets read the same, so a recomputed set that changed
+// nothing a token shows does not repaint every block.
+export function sameTextValues(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
+    }
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length
+        && keys.every((key) => {
+            const other = b[key];
+            return !!other
+                && a[key].name === other.name
+                && a[key].text === other.text
+                && !!a[key].loading === !!other.loading
+                && (a[key].reads ?? []).join(',') === (other.reads ?? []).join(',');
+        });
+}
+// Every component of the report, values included: what owns a filter. A value
+// is never drawn, but its filters are the report's like any other.
+export function reportComponents(report) {
+    if (!report) {
+        return [];
+    }
+    return [
+        ...(report.pages ?? []).flatMap((page) => [...(page.components ?? []), ...(page.values ?? [])]),
+        ...(report.master?.components ?? []),
+        ...(report.master?.values ?? []),
+    ];
+}
+// The value keys each layer holds, by page id and master id. A key that leaves
+// its layer between two loads of the report is a value that was deleted.
+export function layerValueKeys(report) {
+    const layers = new Map();
+    (report?.pages ?? []).forEach((page) => {
+        layers.set(page.id, new Set((page.values ?? []).map(valueKey)));
+    });
+    if (report?.master) {
+        layers.set(report.master.id, new Set((report.master.values ?? []).map(valueKey)));
+    }
+    return layers;
+}
+// Whether a component is drawn on the canvas. A value only ever reads inside
+// text, so one that leaks into a layer's components is still never drawn.
+export function isDrawn(component) {
+    return component.type !== 'value';
+}
+function byId(values) {
+    return [...values].sort((a, b) => a.id - b.id);
+}
+// A formula value's operand keys, lowercase, as its TextValue carries them.
+// Nothing for a query value.
+function formulaReads(value) {
+    return Array.isArray(value.config?.formula?.of) ? { reads: operandKeys(value) } : {};
+}
+// The format a change or a sum is written in when it names none of its own:
+// its first operand's measure, from the newest value on the layer holding that
+// key. Nothing for any other value, whose own format is all it reads.
+function operandSpec(formula, layerValues) {
+    if (formula?.op !== ReportValueFormula.Change && formula?.op !== ReportValueFormula.Sum) {
+        return undefined;
+    }
+    const first = String(formula.of?.[0] ?? '').toLowerCase();
+    return byId(layerValues).filter((value) => valueKey(value) === first).pop()?.config?.measure;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"values.js","sourceRoot":"","sources":["../../../../src/app/reports/values.ts"],"names":[],"mappings":"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","sourcesContent":["import { ReportValueFormula } from './enums/report-value-formula.enum';\nimport { formatOutputValue } from './format';\nimport {\n  NumberFormatSpec,\n  OutputMeta,\n  Report,\n  ReportComponent,\n  ReportFormatContext,\n  ReportPageValue,\n  ValueFormulaConfig,\n} from './interfaces/report.interface';\nimport { TextValue, VALUE_EMPTY_TEXT, VALUE_TOKEN_PATTERN } from './text';\n\n\n// Live values inside text blocks: which values a page's text shows, and what\n// each token reads as. A value belongs to a page (the master for a header or\n// footer) and is listed in its `values`, never in its components. Pure, so the\n// canvas and both exports fill a block's tokens the same way.\n\n// No value keys: what a text block is told other blocks show when nothing\n// says otherwise. Shared, and typed read-only so no caller fills it.\nexport const NO_VALUE_KEYS: ReadonlySet<string> = Object.freeze(new Set<string>());\n\n// The keys an html's {{value.<key>}} tokens name: lowercased, each once, in\n// the order they first appear.\nexport function valueKeys(html: string | null | undefined): string[] {\n  const keys = Array.from((html ?? '').matchAll(VALUE_TOKEN_PATTERN), (match) => match[1].toLowerCase());\n\n  return [...new Set(keys)];\n}\n\n// The key a value's tokens name, as they are compared: lowercase.\nexport function valueKey(component: ReportComponent): string {\n  return String(component.config?.key ?? '').toLowerCase();\n}\n\n// The keys a formula value reads (config.formula.of), as they are compared:\n// lowercase. None for a query value.\nexport function operandKeys(value: ReportComponent): string[] {\n  const of = value.config?.formula?.of;\n\n  return Array.isArray(of) ? of.map((key) => String(key).toLowerCase()) : [];\n}\n\n// The values some text shows, in id order: what the server reads for the\n// page. A key held by two values (a race between two writes) is the newest\n// one's, as server-side.\nexport function shownValues(values: ReportComponent[], texts: ReportComponent[]): ReportComponent[] {\n  const shown = new Set(texts.flatMap((text) => valueKeys(text.config?.html)));\n  const ordered = byId(values);\n  const newest = new Map(ordered.map((value) => [valueKey(value), value]));\n\n  return ordered.filter((value) => shown.has(valueKey(value)) && newest.get(valueKey(value)) === value);\n}\n\n// The keys a layer reads when its text shows `shown`: those keys, and the\n// operands of each shown formula, one level deep. It mirrors the server's\n// ReportTextValues::getReadKeys, and is used only for the editor's notice: the\n// server's own read set decides which numbers come back.\nexport function readKeys(shown: Iterable<string>, values: Record<string, TextValue>): Set<string> {\n  const keys = new Set(shown);\n\n  // Over a copy of the shown keys, so an operand added here is not expanded.\n  [...keys].forEach((key) => {\n    (values[key]?.reads ?? []).forEach((read) => keys.add(read));\n  });\n\n  return keys;\n}\n\n// What each of a layer's values reads as, by key, for its text's tokens and\n// chips. Every value is listed, shown or not, so a pasted chip keeps its name.\n// A value reads as loading until the layer's numbers have arrived (`results`\n// is null until then) and while a request still on its way asks for it\n// (`loading`, by id): a number on screen is always the current request's. A\n// value with no row, or whose row failed, has no text (the em dash).\nexport function textValues(\n  values: ReportComponent[],\n  results: { rows: ReadonlyMap<number, ReportPageValue> } | null,\n  format: ReportFormatContext,\n  loading: ReadonlySet<number> = new Set(),\n): Record<string, TextValue> {\n  const filled: Record<string, TextValue> = {};\n\n  byId(values).forEach((value) => {\n    const key = valueKey(value);\n    const name = value.title || key;\n    const row = results?.rows.get(value.id);\n    const reads = formulaReads(value);\n\n    if (!results || loading.has(value.id)) {\n      filled[key] = { name, loading: true, ...reads };\n    } else if (row && !row.error) {\n      filled[key] = { name, text: formatValueText(value, row, values, format), ...reads };\n    } else {\n      filled[key] = { name, ...reads };\n    }\n  });\n\n  return filled;\n}\n\n// A value's number as its token reads it, on the canvas and in both exports,\n// through the formatOutputValue KPI cards and list cells use. A query value\n// that shows a comparison output, and a formula, are written by their role: a\n// change or a percent change is signed (unless the formula's `signed` says\n// otherwise), and a change in points carries no ' pp', as the words around\n// the token carry the unit. A change or a sum with no format of its own takes\n// its first operand's, and a ratio reads a percent format as a 0-1 fraction.\n// A row with an error reads as the em dash.\nexport function formatValueText(\n  value: ReportComponent,\n  row: ReportPageValue,\n  layerValues: ReportComponent[],\n  ctx: ReportFormatContext,\n): string {\n  if (row.error) {\n    return VALUE_EMPTY_TEXT;\n  }\n\n  const formula = value.config?.formula ?? null;\n  const output: OutputMeta | null = row.role || formula\n    ? {\n      measure: valueKey(value),\n      kind: 'value',\n      role: row.role ?? null,\n      offset: null,\n      window: false,\n      rank: null,\n      share: null,\n    }\n    : null;\n  const context = formula?.op === ReportValueFormula.Ratio ? { ...ctx, ratioPercent: true } : ctx;\n\n  return formatOutputValue(row.value, output, value.config?.measure, context, {\n    empty: VALUE_EMPTY_TEXT,\n    measureSpec: operandSpec(formula, layerValues),\n    signed: formula?.signed ?? undefined,\n    pointsUnit: false,\n  }).text;\n}\n\n// The keys of the values that came back without a number to show: no row for\n// them, or a row with an error. What an export's gate names as failed.\nexport function failedValueKeys(\n  values: ReportComponent[],\n  rows: ReadonlyMap<number, ReportPageValue>,\n): string[] {\n  const failed = values\n    .filter((value) => {\n      const row = rows.get(value.id);\n\n      return !row || !!row.error;\n    })\n    .map(valueKey);\n\n  return [...new Set(failed)];\n}\n\n// Whether two token value sets read the same, so a recomputed set that changed\n// nothing a token shows does not repaint every block.\nexport function sameTextValues(\n  a: Record<string, TextValue> | undefined,\n  b: Record<string, TextValue> | undefined,\n): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  if (!a || !b) {\n    return false;\n  }\n\n  const keys = Object.keys(a);\n\n  return keys.length === Object.keys(b).length\n    && keys.every((key) => {\n      const other = b[key];\n\n      return !!other\n        && a[key].name === other.name\n        && a[key].text === other.text\n        && !!a[key].loading === !!other.loading\n        && (a[key].reads ?? []).join(',') === (other.reads ?? []).join(',');\n    });\n}\n\n// Every component of the report, values included: what owns a filter. A value\n// is never drawn, but its filters are the report's like any other.\nexport function reportComponents(report: Report | null): ReportComponent[] {\n  if (!report) {\n    return [];\n  }\n\n  return [\n    ...(report.pages ?? []).flatMap((page) => [...(page.components ?? []), ...(page.values ?? [])]),\n    ...(report.master?.components ?? []),\n    ...(report.master?.values ?? []),\n  ];\n}\n\n// The value keys each layer holds, by page id and master id. A key that leaves\n// its layer between two loads of the report is a value that was deleted.\nexport function layerValueKeys(report: Report | null): Map<number, Set<string>> {\n  const layers = new Map<number, Set<string>>();\n\n  (report?.pages ?? []).forEach((page) => {\n    layers.set(page.id, new Set((page.values ?? []).map(valueKey)));\n  });\n\n  if (report?.master) {\n    layers.set(report.master.id, new Set((report.master.values ?? []).map(valueKey)));\n  }\n\n  return layers;\n}\n\n// Whether a component is drawn on the canvas. A value only ever reads inside\n// text, so one that leaks into a layer's components is still never drawn.\nexport function isDrawn(component: ReportComponent): boolean {\n  return component.type !== 'value';\n}\n\nfunction byId(values: ReportComponent[]): ReportComponent[] {\n  return [...values].sort((a, b) => a.id - b.id);\n}\n\n// A formula value's operand keys, lowercase, as its TextValue carries them.\n// Nothing for a query value.\nfunction formulaReads(value: ReportComponent): Pick<TextValue, 'reads'> {\n  return Array.isArray(value.config?.formula?.of) ? { reads: operandKeys(value) } : {};\n}\n\n// The format a change or a sum is written in when it names none of its own:\n// its first operand's measure, from the newest value on the layer holding that\n// key. Nothing for any other value, whose own format is all it reads.\nfunction operandSpec(\n  formula: ValueFormulaConfig | null,\n  layerValues: ReportComponent[],\n): NumberFormatSpec | undefined {\n  if (formula?.op !== ReportValueFormula.Change && formula?.op !== ReportValueFormula.Sum) {\n    return undefined;\n  }\n\n  const first = String(formula.of?.[0] ?? '').toLowerCase();\n\n  return byId(layerValues).filter((value) => valueKey(value) === first).pop()?.config?.measure;\n}\n"]}