@firestitch/report 18.6.1 → 18.8.0

package/esm2022/app/reports/list-config.mjs

@@ -0,0 +1,106 @@
+import { laneOutputAlias } from './format';
+// The most leading columns a list can keep in view while it scrolls sideways.
+// Mirrors the server's ListConfig::MAX_PINNED_COLUMNS, which refuses more.
+export const MAX_PINNED_COLUMNS = 3;
+// A list's authored sort, most important first. A list sort is a list of
+// terms, but a list saved before multi-key sorting stores one object and is
+// never rewritten, so both shapes are read here. This is the one reader of a
+// list's config.sort: the config type intersects the chart and list configs,
+// so a direct `config.sort.column` still compiles and silently misreads an
+// array. A term without a column orders nothing and is dropped.
+export function listSortTerms(config) {
+    const sort = config?.sort;
+    if (!sort) {
+        return [];
+    }
+    return (Array.isArray(sort) ? sort : [sort])
+        .filter((term) => !!term?.column);
+}
+// The columns a viewer can hide on a list, by name: a plain list's configured
+// columns. A cross-tab offers none, since its columns are pivot values that
+// come and go with the data.
+export function listHideableColumns(config) {
+    return config?.pivotBy?.column
+        ? []
+        : (config?.columns ?? []).map((column) => column.column);
+}
+// The hidden column names a list honors: only columns it can hide, each once,
+// in the list's own order, and none at all when they would hide every column
+// (a list always shows one, and the server ignores such a CSV list too). The
+// filter state, the screen and every export read this one rule.
+export function listHiddenColumns(config, names) {
+    const hideable = listHideableColumns(config);
+    const hidden = hideable.filter((name) => names.includes(name));
+    return hidden.length < hideable.length ? hidden : [];
+}
+// How many leading columns stay in view while a wide list scrolls sideways.
+// Unset, a cross-tab pins its row-key column and a plain list pins none. A
+// cross-tab pins at most that one column, since the rest are pivot values; a
+// stored config that asks for more is clamped here, as the server refuses it
+// only on save.
+export function listPinnedColumns(config) {
+    const crossTab = !!config?.pivotBy?.column;
+    const pinned = config?.pinnedColumns ?? (crossTab ? 1 : 0);
+    return Math.min(Math.max(Math.floor(Number(pinned) || 0), 0), crossTab ? 1 : MAX_PINNED_COLUMNS);
+}
+// The classes a list column carries on its header, cells and footer. fs-list
+// copies a column's classes once, when it builds the column, so they are
+// static: `report-pin-{index}` names the column's place among the pinned ones
+// (its left offset is a CSS variable the list measures), `report-pin-last`
+// draws the separator after the last pinned column, and `report-nowrap` keeps
+// the column's cells on one line.
+export function columnClasses(column, index, pinned) {
+    const classes = [];
+    if (index < pinned) {
+        classes.push('report-pinned', `report-pin-${index}`);
+        if (index === pinned - 1) {
+            classes.push('report-pin-last');
+        }
+    }
+    if (column.wrap === false) {
+        classes.push('report-nowrap');
+    }
+    return classes.join(' ');
+}
+// The label a list's totals row writes, on screen and in the PDF and deck.
+export const LIST_TOTAL_LABEL = 'Total';
+// The column of a totals row that carries LIST_TOTAL_LABEL, among the columns
+// shown, in order: the first one, unless it holds a total itself, in which
+// case the row has no label. A cross-tab's first column is its row key, which
+// never holds one.
+export function listTotalsLabelColumn(columns, totals) {
+    const first = columns[0];
+    return first && totals?.[first.column] === undefined ? first.column : null;
+}
+// The output columns among a list's columns, by column name, from the
+// metadata its data carries. A cross-tab cell column takes its measure's
+// meaning through cellMeasures; its cells all share the grid's cellFormat and
+// have no prior beside them, since a cross-tab never compares. A column with
+// no output metadata (a plain measure or dimension, an older server) is left
+// out and written as before.
+export function listOutputColumns(columns, data, authored) {
+    const outputs = data?.outputs ?? {};
+    const resolved = {};
+    columns.forEach((column) => {
+        const cellMeasure = data?.cellMeasures?.[column.column];
+        const alias = cellMeasure ?? column.column;
+        const output = outputs[alias];
+        if (output) {
+            resolved[column.column] = {
+                output,
+                measureSpec: authored.find((source) => source.column === output.measure) ?? null,
+                priorAlias: cellMeasure ? null : listPriorAlias(outputs, alias, output),
+                floor: data?.comparison?.floor ?? null,
+            };
+        }
+    });
+    return resolved;
+}
+// A change's or a percent change's prior in the same lane; null for any other
+// output.
+function listPriorAlias(outputs, alias, output) {
+    return output.role === 'change' || output.role === 'percent_change'
+        ? laneOutputAlias(outputs, alias, 'prior')
+        : null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-config.js","sourceRoot":"","sources":["../../../../src/app/reports/list-config.ts"],"names":[],"mappings":"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","sourcesContent":["import { laneOutputAlias } from './format';\nimport {\n  ComponentData,\n  ListColumn,\n  ListConfig,\n  NumberFormatSpec,\n  OutputMeta,\n  ReportSort,\n} from './interfaces/report.interface';\n\n\n// The most leading columns a list can keep in view while it scrolls sideways.\n// Mirrors the server's ListConfig::MAX_PINNED_COLUMNS, which refuses more.\nexport const MAX_PINNED_COLUMNS = 3;\n\n// A list's authored sort, most important first. A list sort is a list of\n// terms, but a list saved before multi-key sorting stores one object and is\n// never rewritten, so both shapes are read here. This is the one reader of a\n// list's config.sort: the config type intersects the chart and list configs,\n// so a direct `config.sort.column` still compiles and silently misreads an\n// array. A term without a column orders nothing and is dropped.\nexport function listSortTerms(config: ListConfig | null | undefined): ReportSort[] {\n  const sort = config?.sort;\n\n  if (!sort) {\n    return [];\n  }\n\n  return (Array.isArray(sort) ? sort : [sort])\n    .filter((term) => !!term?.column);\n}\n\n// The columns a viewer can hide on a list, by name: a plain list's configured\n// columns. A cross-tab offers none, since its columns are pivot values that\n// come and go with the data.\nexport function listHideableColumns(config: ListConfig | null | undefined): string[] {\n  return config?.pivotBy?.column\n    ? []\n    : (config?.columns ?? []).map((column) => column.column);\n}\n\n// The hidden column names a list honors: only columns it can hide, each once,\n// in the list's own order, and none at all when they would hide every column\n// (a list always shows one, and the server ignores such a CSV list too). The\n// filter state, the screen and every export read this one rule.\nexport function listHiddenColumns(config: ListConfig | null | undefined, names: readonly string[]): string[] {\n  const hideable = listHideableColumns(config);\n  const hidden = hideable.filter((name) => names.includes(name));\n\n  return hidden.length < hideable.length ? hidden : [];\n}\n\n// How many leading columns stay in view while a wide list scrolls sideways.\n// Unset, a cross-tab pins its row-key column and a plain list pins none. A\n// cross-tab pins at most that one column, since the rest are pivot values; a\n// stored config that asks for more is clamped here, as the server refuses it\n// only on save.\nexport function listPinnedColumns(config: ListConfig | null | undefined): number {\n  const crossTab = !!config?.pivotBy?.column;\n  const pinned = config?.pinnedColumns ?? (crossTab ? 1 : 0);\n\n  return Math.min(Math.max(Math.floor(Number(pinned) || 0), 0), crossTab ? 1 : MAX_PINNED_COLUMNS);\n}\n\n// The classes a list column carries on its header, cells and footer. fs-list\n// copies a column's classes once, when it builds the column, so they are\n// static: `report-pin-{index}` names the column's place among the pinned ones\n// (its left offset is a CSS variable the list measures), `report-pin-last`\n// draws the separator after the last pinned column, and `report-nowrap` keeps\n// the column's cells on one line.\nexport function columnClasses(column: ListColumn, index: number, pinned: number): string {\n  const classes: string[] = [];\n\n  if (index < pinned) {\n    classes.push('report-pinned', `report-pin-${index}`);\n\n    if (index === pinned - 1) {\n      classes.push('report-pin-last');\n    }\n  }\n\n  if (column.wrap === false) {\n    classes.push('report-nowrap');\n  }\n\n  return classes.join(' ');\n}\n\n// The label a list's totals row writes, on screen and in the PDF and deck.\nexport const LIST_TOTAL_LABEL = 'Total';\n\n// The column of a totals row that carries LIST_TOTAL_LABEL, among the columns\n// shown, in order: the first one, unless it holds a total itself, in which\n// case the row has no label. A cross-tab's first column is its row key, which\n// never holds one.\nexport function listTotalsLabelColumn(\n  columns: readonly ListColumn[],\n  totals: Record<string, unknown> | null | undefined,\n): string | null {\n  const first = columns[0];\n\n  return first && totals?.[first.column] === undefined ? first.column : null;\n}\n\n// How a list column that holds a compared, windowed, ranked or shared output\n// is written (format.ts formatOutputValue): what it holds, the format of its\n// source measure's column, which a prior or a change takes when it names none,\n// the alias of the prior in its lane, whose value in the same row tells a\n// missing baseline from a zero one, and the first day with data.\nexport interface ListOutputColumn {\n  output: OutputMeta;\n  measureSpec: NumberFormatSpec | null;\n  priorAlias: string | null;\n  floor: string | null;\n}\n\n// The output columns among a list's columns, by column name, from the\n// metadata its data carries. A cross-tab cell column takes its measure's\n// meaning through cellMeasures; its cells all share the grid's cellFormat and\n// have no prior beside them, since a cross-tab never compares. A column with\n// no output metadata (a plain measure or dimension, an older server) is left\n// out and written as before.\nexport function listOutputColumns(\n  columns: readonly ListColumn[],\n  data: Pick<ComponentData, 'outputs' | 'cellMeasures' | 'comparison'> | null | undefined,\n  authored: readonly ListColumn[],\n): Record<string, ListOutputColumn> {\n  const outputs = data?.outputs ?? {};\n  const resolved: Record<string, ListOutputColumn> = {};\n\n  columns.forEach((column) => {\n    const cellMeasure = data?.cellMeasures?.[column.column];\n    const alias = cellMeasure ?? column.column;\n    const output = outputs[alias];\n\n    if (output) {\n      resolved[column.column] = {\n        output,\n        measureSpec: authored.find((source) => source.column === output.measure) ?? null,\n        priorAlias: cellMeasure ? null : listPriorAlias(outputs, alias, output),\n        floor: data?.comparison?.floor ?? null,\n      };\n    }\n  });\n\n  return resolved;\n}\n\n// A change's or a percent change's prior in the same lane; null for any other\n// output.\nfunction listPriorAlias(outputs: Record<string, OutputMeta>, alias: string, output: OutputMeta): string | null {\n  return output.role === 'change' || output.role === 'percent_change'\n    ? laneOutputAlias(outputs, alias, 'prior')\n    : null;\n}\n"]}